feat: add typed enums

Add support for typed enums with explicit integer type specifications,
supporting both IEC 61131-3 standard syntax (TYPE NAME : TYPE (...))
and Codesys syntax (TYPE NAME : (...) TYPE).

Author: mhasel

compiler/plc_diagnostics/src/diagnostics/diagnostics_registry.rs

@@ -223,6 +223,7 @@ lazy_static! {
         E119,   Error,      include_str!("./error_codes/E119.md"),  // Invalid use of `SUPER` keyword
         E120,   Error,      include_str!("./error_codes/E120.md"),  // Invalid use of `THIS` keyword
         E121,   Error,      include_str!("./error_codes/E121.md"),  // Recursive type alias
+        E122,   Error,      include_str!("./error_codes/E122.md"),  // Invalid enum base type
     );
 }
 

compiler/plc_diagnostics/src/diagnostics/error_codes/E122.md

@@ -0,0 +1,61 @@
+# E122: Invalid enum base type
+
+This error occurs when an enum is declared with a base type that is not a valid integer type. Enums in IEC 61131-3 can only use integer types as their underlying representation.
+
+## Example
+
+```st
+TYPE Color : STRING (red := 1, green := 2, blue := 3);
+END_TYPE
+```
+
+In this example, `STRING` is not a valid base type for an enum. Only integer types are allowed.
+
+## Another example
+
+```st
+TYPE Status : REAL (active := 1, inactive := 0);
+END_TYPE
+
+TYPE Timestamp : TIME (start := 0, stop := 1);
+END_TYPE
+```
+
+These examples show other invalid base types:
+- `REAL` is a floating-point type, not an integer type
+- `TIME` is a time/date type, which although internally represented as an integer, should not be used as an enum base type
+
+## Valid integer types
+
+The following integer types are valid for enum base types:
+- `INT`, `UINT` - 16-bit integers
+- `SINT`, `USINT` - 8-bit integers
+- `DINT`, `UDINT` - 32-bit integers
+- `LINT`, `ULINT` - 64-bit integers
+- `BYTE` - 8-bit unsigned
+- `WORD` - 16-bit unsigned
+- `DWORD` - 32-bit unsigned
+- `LWORD` - 64-bit unsigned
+
+## How to fix
+
+**Use a valid integer type**
+
+Change the base type to one of the supported integer types:
+
+```st
+TYPE Color : INT (red := 1, green := 2, blue := 3);
+END_TYPE
+
+TYPE Status : BYTE (active := 1, inactive := 0);
+END_TYPE
+```
+
+**Or omit the type specification**
+
+If no specific size is required, you can omit the type specification (will default to `DINT`):
+
+```st
+TYPE Color (red := 1, green := 2, blue := 3);
+END_TYPE
+```

src/codegen/generators/data_type_generator.rs

@@ -366,8 +366,8 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
                             Some(v) => Ok((it.get_qualified_name(), v)),
                             None => self
                                 .types_index
-                                .get_associated_type(it.get_type_name())
-                                .map(get_default_for)
+                                        .get_associated_type(it.get_type_name())
+                                        .map(get_default_for)
                                 .map(|v| (it.get_qualified_name(), v)),
                         })
                     })
@@ -406,6 +406,9 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
             DataTypeInformation::Alias { referenced_type, .. } => {
                 self.generate_initial_value_for_type(data_type, referenced_type)
             }
+            DataTypeInformation::Enum { referenced_type, .. } => {
+                self.generate_initial_value_for_type(data_type, referenced_type)
+            }
             //all other types (scalars, pointer and void)
             _ => Ok(None),
         }

src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_initializers_are_generated.snap

@@ -8,9 +8,9 @@ source_filename = "<internal>"
 target datalayout = "[filtered]"
 target triple = "[filtered]"
 
-@x = global i8 0
-@y = global i16 0
-@z = global i32 0
+@x = global i8 1
+@y = global i16 10
+@z = global i32 22
 @MyEnum.red = unnamed_addr constant i8 1
 @MyEnum.yellow = unnamed_addr constant i8 2
 @MyEnum.green = unnamed_addr constant i8 3

src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_partly_initializers_are_generated.snap

@@ -9,7 +9,7 @@ target datalayout = "[filtered]"
 target triple = "[filtered]"
 
 @twenty = unnamed_addr constant i16 20
-@x = global i8 0
+@x = global i8 7
 @MyEnum.red = unnamed_addr constant i8 7
 @MyEnum.yellow = unnamed_addr constant i8 8
 @MyEnum.green = unnamed_addr constant i8 9

src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__enum_referenced_in_fb_nested.snap

@@ -1,6 +1,7 @@
 ---
 source: src/codegen/tests/multifile_codegen_tests.rs
 expression: "codegen_multi(units, crate::DebugLevel::None).join(\"\\n\")"
+snapshot_kind: text
 ---
 ; ModuleID = 'myEnum.st'
 source_filename = "myEnum.st"
@@ -18,7 +19,7 @@ target triple = "[filtered]"
 
 %fb = type { i32 }
 
-@__fb__init = unnamed_addr constant %fb zeroinitializer
+@__fb__init = unnamed_addr constant %fb { i32 1 }
 
 define void @fb(%fb* %0) {
 entry:
@@ -36,7 +37,7 @@ target triple = "[filtered]"
 %myStruct = type { %fb.2 }
 %fb.2 = type { i32 }
 
-@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer
+@__myStruct__init = unnamed_addr constant %myStruct { %fb.2 { i32 1 } }
 @__fb__init = external unnamed_addr constant %fb.2
 
 declare void @fb(%fb.2*)
@@ -50,7 +51,7 @@ target triple = "[filtered]"
 %myStruct.4 = type { %fb.5 }
 %fb.5 = type { i32 }
 
-@__fb2__init = unnamed_addr constant %fb2 zeroinitializer
+@__fb2__init = unnamed_addr constant %fb2 { %myStruct.4 { %fb.5 { i32 1 } } }
 @__myStruct__init = external unnamed_addr constant %myStruct.4
 @__fb__init = external unnamed_addr constant %fb.5
 

src/codegen/tests/typesystem_test.rs

@@ -312,6 +312,63 @@ fn small_int_varargs_get_promoted_while_32bit_and_higher_keep_their_type() {
     filtered_assert_snapshot!(result);
 }
 
+#[test]
+fn enum_typed_varargs_get_promoted() {
+    let src = r#"
+    {external}
+    FUNCTION printf : DINT
+    VAR_IN_OUT
+        format: STRING;
+    END_VAR
+    VAR_INPUT
+        args: ...;
+    END_VAR
+    END_FUNCTION
+
+    TYPE MyEnum : INT (a := 10, b := 20);
+    END_TYPE
+
+    FUNCTION main : DINT
+    VAR
+        e1 : MyEnum := a;
+        i1 : INT := 10;
+    END_VAR
+        printf('result : %d %d$N', e1, i1);
+    END_FUNCTION
+    "#;
+
+    let result = codegen(src);
+    filtered_assert_snapshot!(result, @r#"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+    target datalayout = "[filtered]"
+    target triple = "[filtered]"
+
+    @MyEnum.a = unnamed_addr constant i16 10
+    @MyEnum.b = unnamed_addr constant i16 20
+    @utf08_literal_0 = private unnamed_addr constant [16 x i8] c"result : %d %d\0A\00"
+
+    declare i32 @printf(i8*, ...)
+
+    define i32 @main() {
+    entry:
+      %main = alloca i32, align 4
+      %e1 = alloca i16, align 2
+      %i1 = alloca i16, align 2
+      store i16 10, i16* %e1, align 2
+      store i16 10, i16* %i1, align 2
+      store i32 0, i32* %main, align 4
+      %load_e1 = load i16, i16* %e1, align 2
+      %0 = sext i16 %load_e1 to i32
+      %load_i1 = load i16, i16* %i1, align 2
+      %1 = sext i16 %load_i1 to i32
+      %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @utf08_literal_0, i32 0, i32 0), i32 %0, i32 %1)
+      %main_ret = load i32, i32* %main, align 4
+      ret i32 %main_ret
+    }
+    "#);
+}
+
 #[test]
 fn self_referential_struct_via_reference_codegen() {
     let result = codegen(

src/index/indexer/user_type_indexer.rs

@@ -292,8 +292,10 @@ impl UserTypeIndexer<'_, '_> {
 
     fn index_enum_type(&mut self, name: &str, numeric_type: &str, elements: &AstNode) {
         let mut variants = Vec::new();
+        let mut zero_value_const_id: Option<ConstId> = None;
+        let mut first_element_const_id: Option<ConstId> = None;
 
-        for ele in flatten_expression_list(elements) {
+        for (idx, ele) in flatten_expression_list(elements).iter().enumerate() {
             let variant = get_enum_element_name(ele);
             if let AstStatement::Assignment(Assignment { right, .. }) = ele.get_stmt() {
                 let scope = self.current_scope();
@@ -304,6 +306,16 @@ impl UserTypeIndexer<'_, '_> {
                     None,
                 );
 
+                // Track if we have a zero element and remember its ConstId
+                if let AstStatement::Literal(AstLiteral::Integer(0)) = right.get_stmt() {
+                    zero_value_const_id = Some(init);
+                }
+
+                // Remember the first element's ConstId
+                if idx == 0 {
+                    first_element_const_id = Some(init);
+                }
+
                 variants.push(self.index.register_enum_variant(
                     name,
                     &variant,
@@ -315,6 +327,17 @@ impl UserTypeIndexer<'_, '_> {
             }
         }
 
+        // If no explicit initializer was provided, determine the default value
+        if self.pending_initializer.is_none() {
+            self.pending_initializer = if zero_value_const_id.is_some() {
+                // If zero is defined, use its ConstId
+                zero_value_const_id
+            } else {
+                // Otherwise use the first element's ConstId
+                first_element_const_id
+            };
+        }
+
         let information = DataTypeInformation::Enum {
             name: name.to_owned(),
             variants,

src/parser.rs

@@ -963,7 +963,6 @@ fn parse_data_type_definition(
     } else if lexer.try_consume(KeywordRef) {
         parse_pointer_definition(lexer, name, lexer.last_range.start, None, true, false)
     } else if lexer.try_consume(KeywordParensOpen) {
-        //enum without datatype
         parse_enum_type_definition(lexer, name)
     } else if lexer.token == KeywordString || lexer.token == KeywordWideString {
         parse_string_type_definition(lexer, name)
@@ -1095,6 +1094,9 @@ fn parse_string_size_expression(lexer: &mut ParseSession) -> Option<AstNode> {
             let size_expr = parse_expression(lexer);
             let error_range = lexer.source_range_factory.create_range(opening_location..lexer.range().end);
 
+            // Don't emit warnings if this looks like an enum (will be caught by validation)
+            let is_enum_like = matches!(size_expr.get_stmt(), AstStatement::ExpressionList(_));
+
             if (opening_token == KeywordParensOpen && lexer.token == KeywordSquareParensClose)
                 || (opening_token == KeywordSquareParensOpen && lexer.token == KeywordParensClose)
             {
@@ -1103,7 +1105,7 @@ fn parse_string_size_expression(lexer: &mut ParseSession) -> Option<AstNode> {
                         .with_location(error_range)
                         .with_error_code("E009"),
                 );
-            } else if opening_token == KeywordParensOpen || lexer.token == KeywordParensClose {
+            } else if !is_enum_like && (opening_token == KeywordParensOpen || lexer.token == KeywordParensClose) {
                 lexer.accept_diagnostic(Diagnostic::new(
                     "Unusual type of parentheses around string size expression, consider using square parentheses '[]'").
                     with_location(error_range)
@@ -1131,13 +1133,33 @@ fn parse_string_type_definition(
     let end = lexer.last_range.end;
     let location = lexer.source_range_factory.create_range(start..end);
 
-    match (size, &name) {
-        (Some(size), _) => Some(DataTypeDeclaration::Definition {
+    // Check if this is actually an enum type (e.g., STRING (a := 1, b := 2))
+    // If size is an ExpressionList with assignments, it's likely an invalid enum definition
+    let is_enum_like = matches!(
+        &size,
+        Some(AstNode { stmt: AstStatement::ExpressionList(_), .. })
+    );
+
+    match (size, &name, is_enum_like) {
+        (Some(size), _, true) => {
+            // This looks like an enum definition with STRING/WSTRING as the type
+            // Create an EnumType so validation can catch it as invalid
+            Some(DataTypeDeclaration::Definition {
+                data_type: Box::new(DataType::EnumType {
+                    name,
+                    numeric_type: text,
+                    elements: size,
+                }),
+                location,
+                scope: lexer.scope.clone(),
+            })
+        }
+        (Some(size), _, false) => Some(DataTypeDeclaration::Definition {
             data_type: Box::new(DataType::StringType { name, is_wide, size: Some(size) }),
             location,
             scope: lexer.scope.clone(),
         }),
-        (None, Some(name)) => Some(DataTypeDeclaration::Definition {
+        (None, Some(name), _) => Some(DataTypeDeclaration::Definition {
             data_type: Box::new(DataType::SubRangeType {
                 name: Some(name.into()),
                 referenced_type: text,
@@ -1164,10 +1186,19 @@ fn parse_enum_type_definition(
         let elements = parse_expression_list(lexer);
         Some(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 {
-            data_type: Box::new(DataType::EnumType { name, elements, numeric_type: DINT_TYPE.to_string() }),
+            data_type: Box::new(DataType::EnumType { name, elements, numeric_type }),
             location: start.span(&lexer.last_location()),
             scope: lexer.scope.clone(),
         },