chore: use strum to iterate enum fields

lsp/Cargo.toml

@@ -13,4 +13,6 @@ tokio-util = { version = "*", features = ["codec"] }
 serde_json = "*"
 tracing = "*"
 tracing-subscriber = { version = "*", features = ["env-filter"] }
-once_cell = "*"
+once_cell = "*"
+strum = "*"
+strum_macros = "*"

lsp/src/lsp.rs

@@ -1,58 +1,32 @@
+use crate::lsp_types::{TokenModifiers, TokenTypes};
+
 use serde_json::Value;
 use stc::parser::{StLexerBuilder, Tok};
+use strum::IntoEnumIterator;
 use tower_lsp::jsonrpc;
 use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::*;
 use tower_lsp::{Client, LanguageServer};
 use tracing::*;
 
-const TOKEN_MODIFIERS: &[SemanticTokenModifier] = &[
-    SemanticTokenModifier::new("none"),
-    // 1, STATIC
-    SemanticTokenModifier::STATIC,
-    // 2, GLOBAL
-    SemanticTokenModifier::new("global"),
-    // 4, RETAIN
-    SemanticTokenModifier::new("retain"),
-];
-
-const TOKEN_TYPES: &[SemanticTokenType] = &[
-    // 0, NONE
-    SemanticTokenType::new("none"),
-    // 1, keywords
-    SemanticTokenType::KEYWORD,
-    // 2, identifiers
-    SemanticTokenType::VARIABLE,
-    // 3, operators
-    SemanticTokenType::OPERATOR,
-    // 4, builtin functions
-    SemanticTokenType::new("builtin-functions"),
-    // 5, number literals
-    SemanticTokenType::NUMBER,
-    // 6, string literals
-    SemanticTokenType::STRING,
-    // 7, type
-    SemanticTokenType::TYPE,
-];
-
 fn semantic_token_type_id(tok: &Tok) -> (u32, u32) {
     match tok {
-        Tok::Identifier(_) => (2, 0),
-        Tok::Literal(_) => (5, 0),
-        Tok::String => (6, 0),
+        Tok::Identifier(_) => (TokenTypes::Variable as u32, TokenModifiers::None as u32),
+        Tok::Literal(_) => (TokenTypes::Number as u32, TokenModifiers::None as u32),
+        Tok::String => (TokenTypes::String as u32, TokenModifiers::None as u32),
         // operators
-        op if op.is_operator() => (3, 0),
+        op if op.is_operator() => (TokenTypes::Operator as u32, TokenModifiers::None as u32),
         // builtin-types
-        Tok::Int => (7, 0),
+        Tok::Int => (TokenTypes::Type as u32, TokenModifiers::None as u32),
         // keywords
         Tok::If
         | Tok::Then
         | Tok::EndIf
         | Tok::Var
         | Tok::EndVar
         | Tok::Program
-        | Tok::EndProgram => (1, 0),
-        _ => (0, 0),
+        | Tok::EndProgram => (TokenTypes::Keyword as u32, TokenModifiers::None as u32),
+        _ => (TokenTypes::None as u32, TokenModifiers::None as u32),
     }
 }
 
@@ -74,8 +48,8 @@ impl LanguageServer for StcLsp {
                         work_done_progress: None,
                     },
                     legend: SemanticTokensLegend {
-                        token_types: TOKEN_TYPES.to_vec(),
-                        token_modifiers: TOKEN_MODIFIERS.to_vec(),
+                        token_types: TokenTypes::iter().map(Into::into).collect(),
+                        token_modifiers: TokenModifiers::iter().map(Into::into).collect(),
                     },
                     range: Some(true),
                     full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),

lsp/src/lsp_types.rs

@@ -0,0 +1,46 @@
+use strum_macros::{Display, EnumIter};
+use tower_lsp::lsp_types::{SemanticTokenModifier, SemanticTokenType};
+
+#[derive(Debug, PartialEq, Eq, EnumIter, Display)]
+#[repr(u32)]
+pub enum TokenTypes {
+    None,
+    Keyword,
+    Variable,
+    Operator,
+    BuiltinFunction,
+    Number,
+    String,
+    Type,
+}
+
+impl From<TokenTypes> for SemanticTokenType {
+    fn from(value: TokenTypes) -> Self {
+        match value {
+            TokenTypes::None => SemanticTokenType::new("none"),
+            TokenTypes::Keyword => SemanticTokenType::KEYWORD,
+            TokenTypes::Variable => SemanticTokenType::VARIABLE,
+            TokenTypes::Operator => SemanticTokenType::OPERATOR,
+            TokenTypes::BuiltinFunction => SemanticTokenType::new("builtin-functions"),
+            TokenTypes::Number => SemanticTokenType::NUMBER,
+            TokenTypes::String => SemanticTokenType::STRING,
+            TokenTypes::Type => SemanticTokenType::TYPE,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, EnumIter, Display)]
+#[repr(u32)]
+pub enum TokenModifiers {
+    None,
+    Static,
+}
+
+impl From<TokenModifiers> for SemanticTokenModifier {
+    fn from(value: TokenModifiers) -> Self {
+        match value {
+            TokenModifiers::None => SemanticTokenModifier::new("none"),
+            TokenModifiers::Static => SemanticTokenModifier::STATIC,
+        }
+    }
+}

lsp/src/main.rs

@@ -1,4 +1,5 @@
 mod lsp;
+mod lsp_types;
 
 use lsp::StcLsp;
 use std::io;