🧹 Refactor test_token_uniqueness using strum EnumIter

compiler/syntax/Cargo.toml

@@ -7,6 +7,8 @@ description = "Token definitions, keywords, and operator precedence for TechScri
 [dependencies]
 techscript_common = { path = "../common" }
 serde = { workspace = true }
+strum = "0.28.0"
+strum_macros = "0.28.0"
 
 [dev-dependencies]
 serde_json = { workspace = true }

compiler/syntax/src/token_kind.rs

@@ -5,7 +5,9 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 
 /// Classification of literal values in TechScript 2.0.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, strum_macros::EnumIter,
+)]
 pub enum LiteralKind {
     /// Integer literal (e.g., `42`).
     Int,
@@ -50,7 +52,9 @@ impl fmt::Display for NumericLiteralKind {
 /// - **Canonical 2.0**: The one true spelling — no warnings emitted.
 /// - **Deprecated Alias**: Old spelling — still parsed, but emits a `TSW1xxx` warning.
 /// - **Reserved**: Recognised by the lexer but not yet active.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, strum_macros::EnumIter,
+)]
 pub enum TokenKind {
     // ── Canonical 2.0 Keywords ──────────────────────────────────────────────────────
     /// `do` — function/method declaration (replaces `build`, `fun`, `function`)

compiler/syntax/tests/syntax_tests.rs

@@ -378,114 +378,20 @@ fn test_serde_roundtrips() {
 
 #[test]
 fn test_token_uniqueness() {
+    use strum::IntoEnumIterator;
     // Ensure all TokenKind static_lexemes are unique
     let mut lexemes = HashSet::new();
-    let kinds = [
-        TokenKind::Do,
-        TokenKind::Send,
-        TokenKind::When,
-        TokenKind::Loop,
-        TokenKind::Repeat,
-        TokenKind::For,
-        TokenKind::In,
-        TokenKind::Match,
-        TokenKind::Case,
-        TokenKind::Default,
-        TokenKind::Try,
-        TokenKind::Catch,
-        TokenKind::Throw,
-        TokenKind::Use,
-        TokenKind::Class,
-        TokenKind::Struct,
-        TokenKind::Enum,
-        TokenKind::Trait,
-        TokenKind::Interface,
-        TokenKind::Const,
-        TokenKind::Null,
-        TokenKind::Say,
-        TokenKind::Ask,
-        TokenKind::Break,
-        TokenKind::Continue,
-        TokenKind::Else,
-        TokenKind::Async,
-        TokenKind::Await,
-        TokenKind::Parallel,
-        TokenKind::End,
-        TokenKind::Export,
-        TokenKind::New,
-        TokenKind::SelfKw,
-        TokenKind::True,
-        TokenKind::False,
-        TokenKind::Typeof,
-        TokenKind::With,
-        TokenKind::Build,
-        TokenKind::Make,
-        TokenKind::Return,
-        TokenKind::Model,
-        TokenKind::If,
-        TokenKind::Elif,
-        TokenKind::While,
-        TokenKind::Import,
-        TokenKind::From,
-        TokenKind::Let,
-        TokenKind::Var,
-        TokenKind::Fun,
-        TokenKind::Function,
-        TokenKind::Attempt,
-        TokenKind::None,
-        TokenKind::Keep,
-        TokenKind::Give,
-        TokenKind::Stop,
-        TokenKind::Skip,
-        TokenKind::Each,
-        TokenKind::Switch,
-        TokenKind::Be,
-        TokenKind::Equals,
-        TokenKind::Then,
-        TokenKind::Plus,
-        TokenKind::Minus,
-        TokenKind::Star,
-        TokenKind::Slash,
-        TokenKind::DoubleSlash,
-        TokenKind::Percent,
-        TokenKind::DoubleStar,
-        TokenKind::EqualEqual,
-        TokenKind::BangEqual,
-        TokenKind::TripleEqual,
-        TokenKind::BangEqualEqual,
-        TokenKind::Less,
-        TokenKind::Greater,
-        TokenKind::LessEqual,
-        TokenKind::GreaterEqual,
-        TokenKind::Equal,
-        TokenKind::PlusEqual,
-        TokenKind::MinusEqual,
-        TokenKind::StarEqual,
-        TokenKind::SlashEqual,
-        TokenKind::PercentEqual,
-        TokenKind::DotDot,
-        TokenKind::DotDotEqual,
-        TokenKind::QuestionDot,
-        TokenKind::QuestionQuestion,
-        TokenKind::Arrow,
-        TokenKind::LeftParen,
-        TokenKind::RightParen,
-        TokenKind::LeftBrace,
-        TokenKind::RightBrace,
-        TokenKind::LeftBracket,
-        TokenKind::RightBracket,
-        TokenKind::Comma,
-        TokenKind::Dot,
-        TokenKind::Colon,
-        TokenKind::Semicolon,
-    ];
 
-    for kind in kinds {
-        let lexeme = kind.static_lexeme().unwrap();
-        assert!(
-            lexemes.insert(lexeme),
-            "Duplicate static lexeme detected for: {:?}",
-            kind
-        );
+    for kind in TokenKind::iter() {
+        if kind == TokenKind::FStringExprStart || kind == TokenKind::FStringExprEnd {
+            continue; // Overlaps with LeftBrace/RightBrace logically, but handled contextually
+        }
+        if let Some(lexeme) = kind.static_lexeme() {
+            assert!(
+                lexemes.insert(lexeme),
+                "Duplicate static lexeme detected for: {:?}",
+                kind
+            );
+        }
     }
 }