Skip to main content

logicaffeine_language/
token_class.rs

1//! How LOGOS tokens are classified for highlighting: parts of speech are the
2//! syntax — verbs paint as functions, nouns as types, adjectives as
3//! modifiers. Every highlighting surface (LSP semantic tokens, the terminal
4//! REPL, any future renderer) derives its colors from this mapping, so they
5//! can never disagree.
6//!
7//! The match is deliberately wildcard-free: adding a `TokenType` variant
8//! does not compile until someone decides its class — the decision lives
9//! here, next to the enum, not in an editor plugin.
10
11use crate::token::TokenType;
12
13/// What a token IS, presentation-wise. Mirrors the LSP semantic-token
14/// vocabulary (the LSP legend maps 1:1; the REPL maps to ANSI colors).
15#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16pub enum TokenClass {
17    Keyword,
18    Type,
19    Function,
20    Variable,
21    String,
22    Number,
23    Operator,
24    Namespace,
25    Modifier,
26    Property,
27    Comment,
28    Parameter,
29    EnumMember,
30}
31
32/// The statement vocabulary of imperative LOGOS, as one pattern: [`classify`] calls these
33/// keywords and [`is_imperative_keyword`] names them, from this single list.
34macro_rules! imperative_keywords {
35    () => {
36        TokenType::Let
37            | TokenType::Set
38            | TokenType::Swap
39            | TokenType::Return
40            | TokenType::Break
41            | TokenType::Be
42            | TokenType::While
43            | TokenType::Repeat
44            | TokenType::For
45            | TokenType::In
46            | TokenType::From
47            | TokenType::Assert
48            | TokenType::Trust
49            | TokenType::Require
50            | TokenType::Requires
51            | TokenType::Ensures
52            | TokenType::Expect
53            | TokenType::Advance
54            | TokenType::Skip
55            | TokenType::Note
56            | TokenType::Warn
57            | TokenType::Record
58            | TokenType::During
59            | TokenType::Otherwise
60            | TokenType::Else
61            | TokenType::Elif
62            | TokenType::Call
63            | TokenType::New
64            | TokenType::Either
65            | TokenType::Inspect
66            | TokenType::Native
67            | TokenType::Escape
68            | TokenType::Given
69            | TokenType::Prove
70            | TokenType::Auto
71            | TokenType::Read
72            | TokenType::Write
73            | TokenType::Console
74            | TokenType::File
75            | TokenType::Give
76            | TokenType::Show
77            | TokenType::Push
78            | TokenType::Pop
79            | TokenType::Copy
80            | TokenType::Through
81            | TokenType::Length
82            | TokenType::At
83            | TokenType::Add
84            | TokenType::Remove
85            | TokenType::Contains
86            | TokenType::Union
87            | TokenType::Intersection
88            | TokenType::Inside
89            | TokenType::Zone
90            | TokenType::Called
91            | TokenType::Size
92            | TokenType::Mapped
93            | TokenType::Attempt
94            | TokenType::Following
95            | TokenType::Simultaneously
96            | TokenType::Spawn
97            | TokenType::Send
98            | TokenType::Await
99            | TokenType::Portable
100            | TokenType::Manifest
101            | TokenType::Chunk
102            | TokenType::Shared
103            | TokenType::Merge
104            | TokenType::Converge
105            | TokenType::Increase
106            | TokenType::Decrease
107            | TokenType::Tally
108            | TokenType::SharedSet
109            | TokenType::SharedSequence
110            | TokenType::CollaborativeSequence
111            | TokenType::SharedMap
112            | TokenType::Divergent
113            | TokenType::Append
114            | TokenType::Resolve
115            | TokenType::RemoveWins
116            | TokenType::AddWins
117            | TokenType::YATA
118            | TokenType::Values
119            | TokenType::Check
120            | TokenType::Listen
121            | TokenType::NetConnect
122            | TokenType::Sleep
123            | TokenType::Sync
124            | TokenType::Mount
125            | TokenType::Persistent
126            | TokenType::Combined
127            | TokenType::Followed
128            | TokenType::Launch
129            | TokenType::Task
130            | TokenType::Pipe
131            | TokenType::Receive
132            | TokenType::Stop
133            | TokenType::Try
134            | TokenType::Into
135            | TokenType::First
136            | TokenType::After
137            | TokenType::Mut
138    };
139}
140
141/// Classify a token by its part of speech. `None` = a token no surface paints
142/// as ONE token: the structural ones (indent/dedent/newline/EOF), and an LGX
143/// raw section, whose body is painted by the language it is written in.
144pub fn classify(kind: &TokenType) -> Option<TokenClass> {
145    classify_inner(kind, 0)
146}
147
148const MAX_AMBIGUOUS_DEPTH: usize = 3;
149
150/// Is this token a statement word of imperative LOGOS — `Let`, `Otherwise`, `Give`, `Send`, … —
151/// as opposed to the English function words (`a`, `is`, `of`) that also class as keywords?
152/// An ambiguous token answers by its primary reading, as [`classify`] does.
153pub fn is_imperative_keyword(kind: &TokenType) -> bool {
154    imperative_inner(kind, 0)
155}
156
157fn imperative_inner(kind: &TokenType, depth: usize) -> bool {
158    match kind {
159        imperative_keywords!() => true,
160        TokenType::Ambiguous { primary, .. } if depth < MAX_AMBIGUOUS_DEPTH => {
161            imperative_inner(primary, depth + 1)
162        }
163        _ => false,
164    }
165}
166
167fn classify_inner(kind: &TokenType, depth: usize) -> Option<TokenClass> {
168    match kind {
169        // Quantifiers → keyword
170        TokenType::All
171        | TokenType::No
172        | TokenType::Some
173        | TokenType::Any
174        | TokenType::Both
175        | TokenType::Most
176        | TokenType::Few
177        | TokenType::Many
178        | TokenType::Cardinal(_)
179        | TokenType::AtLeast(_)
180        | TokenType::AtMost(_)
181        | TokenType::InfinitelyMany
182        | TokenType::FinitelyMany
183        | TokenType::AllButFinitelyMany
184        | TokenType::InfinitelyOften => {
185            Some(TokenClass::Keyword) // keyword
186        }
187
188        // Logical connectives → operator
189        TokenType::And
190        | TokenType::Or
191        | TokenType::Not
192        | TokenType::If
193        | TokenType::Then
194        | TokenType::Iff
195        | TokenType::Because
196        | TokenType::Although
197        | TokenType::Until
198        | TokenType::Release
199        | TokenType::WeakUntil
200        | TokenType::Implies => {
201            Some(TokenClass::Operator) // operator
202        }
203
204        // Modal operators → keyword
205        TokenType::Must
206        | TokenType::Shall
207        | TokenType::Should
208        | TokenType::Can
209        | TokenType::May
210        | TokenType::Cannot
211        | TokenType::Would
212        | TokenType::Could
213        | TokenType::Might
214        | TokenType::Had => {
215            Some(TokenClass::Keyword) // keyword
216        }
217
218        // Imperative keywords → keyword
219        imperative_keywords!() => Some(TokenClass::Keyword),
220
221        // Nouns → type
222        TokenType::Noun(_) => Some(TokenClass::Type),
223
224        // Verbs → function
225        TokenType::Verb { .. } => Some(TokenClass::Function),
226
227        // Adjectives → modifier
228        TokenType::Adjective(_) | TokenType::NonIntersectiveAdjective(_) => {
229            Some(TokenClass::Modifier) // modifier
230        }
231
232        // Proper names → variable with declaration modifier
233        TokenType::ProperName(_) => Some(TokenClass::Variable), // variable + declaration
234
235        // Pronouns → variable
236        TokenType::Pronoun { .. } => Some(TokenClass::Variable),
237
238        // Articles → keyword
239        TokenType::Article(_) => Some(TokenClass::Keyword),
240
241        // Copula → keyword
242        TokenType::Is | TokenType::Are | TokenType::Was | TokenType::Were => {
243            Some(TokenClass::Keyword)
244        }
245
246        // Wh-words → keyword
247        TokenType::That
248        | TokenType::Who
249        | TokenType::Whose
250        | TokenType::What
251        | TokenType::Where
252        | TokenType::When
253        | TokenType::Why
254        | TokenType::Does
255        | TokenType::Do => Some(TokenClass::Keyword),
256
257        // `is equal to` and `equals` are `==` in English: operators.
258        TokenType::Identity | TokenType::Equals => Some(TokenClass::Operator),
259
260        // Reflexive → keyword
261        TokenType::Reflexive
262        | TokenType::Reciprocal
263        | TokenType::Respectively => Some(TokenClass::Keyword),
264
265        // String literals → string
266        TokenType::StringLiteral(_)
267        | TokenType::InterpolatedString(_)
268        | TokenType::CharLiteral(_) => Some(TokenClass::String),
269
270        // Number literals → number
271        TokenType::Number(_)
272        | TokenType::MoneyLiteral { .. }
273        | TokenType::DurationLiteral { .. }
274        | TokenType::DateLiteral { .. }
275        | TokenType::TimeLiteral { .. } => Some(TokenClass::Number),
276
277        // Operators → operator
278        TokenType::Plus
279        | TokenType::Minus
280        | TokenType::Star
281        | TokenType::Slash
282        | TokenType::Percent
283        | TokenType::Lt
284        | TokenType::Gt
285        | TokenType::LtEq
286        | TokenType::GtEq
287        | TokenType::EqEq
288        | TokenType::NotEq
289        | TokenType::Arrow
290        | TokenType::Assign
291        | TokenType::Xor
292        | TokenType::Shifted
293        | TokenType::Amp
294        | TokenType::VBar
295        | TokenType::Tilde
296        | TokenType::Caret
297        | TokenType::Dot
298        | TokenType::StarStar
299        | TokenType::SlashSlash
300        | TokenType::PlusEq
301        | TokenType::MinusEq
302        | TokenType::StarEq
303        | TokenType::SlashEq
304        | TokenType::PercentEq => Some(TokenClass::Operator),
305
306        // Block headers → namespace
307        TokenType::BlockHeader { .. } => Some(TokenClass::Namespace),
308
309        // Prepositions → keyword
310        TokenType::Preposition(_) => Some(TokenClass::Keyword),
311
312        // Generic identifier → variable
313        TokenType::Identifier => Some(TokenClass::Variable),
314
315        // Comparatives/superlatives → modifier
316        TokenType::Comparative(_) | TokenType::Superlative(_) | TokenType::Than => {
317            Some(TokenClass::Modifier)
318        }
319
320        // Calendar/temporal → keyword
321        TokenType::CalendarUnit(_)
322        | TokenType::Ago
323        | TokenType::Hence
324        | TokenType::Before
325        | TokenType::TemporalAdverb(_) => Some(TokenClass::Keyword),
326
327        // Item/Items → keyword
328        TokenType::Item | TokenType::Items => Some(TokenClass::Keyword),
329
330        // Adverbs → modifier
331        TokenType::Adverb(_) | TokenType::ScopalAdverb(_) => Some(TokenClass::Modifier),
332
333        // Focus/presup → keyword
334        TokenType::Focus(_) | TokenType::PresupTrigger(_) | TokenType::Measure(_) => {
335            Some(TokenClass::Keyword)
336        }
337
338        // Auxiliary → keyword
339        TokenType::Auxiliary(_) => Some(TokenClass::Keyword),
340
341        // Escape blocks → string (raw code)
342        TokenType::EscapeBlock(_) => Some(TokenClass::String),
343        // A `View:` / `Style:` / `Head:` body is another language (HTML with holes, CSS), so it
344        // has no class of its own: a surface paints its INSIDE by that language's rules, and one
345        // class over the whole body would hide them.
346        TokenType::RawBlock { .. } => None,
347
348        // Performative → keyword
349        TokenType::Performative(_) => Some(TokenClass::Keyword),
350        TokenType::Exclamation => Some(TokenClass::Keyword),
351
352        // NPIs → keyword
353        TokenType::Anything
354        | TokenType::Anyone
355        | TokenType::Nothing
356        | TokenType::Nobody
357        | TokenType::NoOne
358        | TokenType::Nowhere
359        | TokenType::Ever
360        | TokenType::Never => Some(TokenClass::Keyword),
361
362        // Ambiguous → try primary classification with depth guard
363        TokenType::Ambiguous { primary, .. } => {
364            if depth >= MAX_AMBIGUOUS_DEPTH {
365                return None;
366            }
367            classify_inner(primary, depth + 1)
368        }
369
370        // Particles → keyword
371        TokenType::Particle(_) => Some(TokenClass::Keyword),
372
373        // Control → keyword
374        TokenType::To => Some(TokenClass::Keyword),
375
376        // Possessive → operator
377        TokenType::Possessive => Some(TokenClass::Operator),
378
379        // Punctuation → skip (or operator for comma/period)
380        TokenType::Period | TokenType::Comma | TokenType::Colon => Some(TokenClass::Operator),
381        TokenType::LParen
382        | TokenType::RParen
383        | TokenType::LBracket
384        | TokenType::RBracket
385        | TokenType::LBrace
386        | TokenType::RBrace => Some(TokenClass::Operator),
387
388        // Structural tokens → skip
389        TokenType::Indent | TokenType::Dedent | TokenType::Newline | TokenType::EOF => None,
390    }
391}
392
393#[cfg(test)]
394#[path = "../../logicaffeine_tests/unit/logicaffeine_language/token_class/imperative_keyword_tests.rs"]
395mod imperative_keyword_tests;