fix: panic when using equality rather than assignment operator in enum defnition

src/parser.rs

@@ -33,7 +33,7 @@ use crate::{
 
 use self::{
     control_parser::parse_control_statement,
-    expressions_parser::{parse_expression, parse_expression_list},
+    expressions_parser::{parse_expression, parse_range_statement},
 };
 
 mod control_parser;
@@ -1176,17 +1176,12 @@ fn parse_enum_type_definition(
     name: Option<String>,
 ) -> Option<(DataTypeDeclaration, Option<AstNode>)> {
     let start = lexer.last_location();
-    let elements = parse_any_in_region(lexer, vec![KeywordParensClose], |lexer| {
-        // Parse Enum - we expect at least one element
-        let elements = parse_expression_list(lexer);
-        Some(elements)
-    })?;
 
+    let elements = parse_any_in_region(lexer, vec![KeywordParensClose], parse_enum_elements)?;
     // Check for Codesys-style type specification after the enum list
     // TYPE COLOR : (...) DWORD;
     let numeric_type =
         if lexer.token == Identifier { lexer.slice_and_advance() } else { DINT_TYPE.to_string() };
-
     let initializer = lexer.try_consume(KeywordAssignment).then(|| parse_expression(lexer));
     Some((
         DataTypeDeclaration::Definition {
@@ -1198,6 +1193,60 @@ fn parse_enum_type_definition(
     ))
 }
 
+/// Parse comma-separated enum elements (identifier or identifier := literal)
+fn parse_enum_elements(lexer: &mut ParseSession) -> Option<AstNode> {
+    let start = lexer.location();
+    let mut elements = vec![];
+
+    loop {
+        // Check if we've hit the closing token (e.g., ')') immediately
+        // This handles empty enums like `()` for error recovery
+        if lexer.closes_open_region(&lexer.token) {
+            break;
+        }
+
+        let element = parse_enum_element(lexer)?;
+        elements.push(element);
+
+        if !lexer.try_consume(KeywordComma) {
+            break;
+        }
+
+        if lexer.closes_open_region(&lexer.token) {
+            break;
+        }
+    }
+
+    // Handle empty enum case (no elements parsed)
+    if elements.is_empty() {
+        return Some(AstFactory::create_empty_statement(start, lexer.next_id()));
+    }
+
+    if elements.len() == 1 {
+        return Some(elements.into_iter().next().unwrap());
+    }
+
+    Some(AstFactory::create_expression_list(elements, start.span(&lexer.last_location()), lexer.next_id()))
+}
+
+/// Parse a single enum element: identifier or identifier := literal
+fn parse_enum_element(lexer: &mut ParseSession) -> Option<AstNode> {
+    let start = lexer.location();
+
+    let idfr = parse_identifier(lexer)?;
+
+    let identifier_node = AstFactory::create_identifier(&idfr.0, start, lexer.next_id());
+    let ref_expr = AstFactory::create_member_reference(identifier_node, None, lexer.next_id());
+
+    if lexer.try_consume(KeywordAssignment) {
+        let value = parse_range_statement(lexer);
+        let result = AstFactory::create_assignment(ref_expr, value, lexer.next_id());
+        return Some(result);
+    }
+
+    Some(ref_expr)
+}
+
 fn parse_array_type_definition(
     lexer: &mut ParseSession,
     name: Option<String>,

src/parser/tests/snapshots/rusty__parser__tests__type_parser_tests__enum_with_call_statement_as_variant_should_error.snap

@@ -0,0 +1,15 @@
+---
+source: src/parser/tests/type_parser_tests.rs
+expression: diagnostics
+---
+error[E007]: Unexpected token: expected KeywordParensClose but found '('
+  ┌─ <internal>:2:37
+  │
+2 │         TYPE State : (Idle := 0, foo());
+  │                                     ^ Unexpected token: expected KeywordParensClose but found '('
+
+error[E007]: Unexpected token: expected KeywordSemicolon but found ')'
+  ┌─ <internal>:2:39
+  │
+2 │         TYPE State : (Idle := 0, foo());
+  │                                       ^ Unexpected token: expected KeywordSemicolon but found ')'

src/parser/tests/snapshots/rusty__parser__tests__type_parser_tests__enum_with_equality_operator_instead_of_assignment_should_error.snap

@@ -0,0 +1,9 @@
+---
+source: src/parser/tests/type_parser_tests.rs
+expression: diagnostics
+---
+error[E007]: Unexpected token: expected KeywordParensClose but found '= 1'
+  ┌─ <internal>:2:42
+  │
+2 │         TYPE State : (Idle := 0, Running = 1);
+  │                                          ^^^ Unexpected token: expected KeywordParensClose but found '= 1'

src/parser/tests/snapshots/rusty__parser__tests__type_parser_tests__enum_with_qualified_member_variant_should_error.snap

@@ -0,0 +1,9 @@
+---
+source: src/parser/tests/type_parser_tests.rs
+expression: diagnostics
+---
+error[E007]: Unexpected token: expected KeywordParensClose but found '.Fast, Running.Slow'
+  ┌─ <internal>:2:41
+  │
+2 │         TYPE State : (Idle := 0, Running.Fast, Running.Slow);
+  │                                         ^^^^^^^^^^^^^^^^^^^ Unexpected token: expected KeywordParensClose but found '.Fast, Running.Slow'