move evaluation to its own pass after constant resolution

Author: mhasel

compiler/plc_driver/src/pipelines.rs

@@ -561,7 +561,11 @@ impl ParsedProject {
         global_index.import(indexer::index(&builtins));
 
         //TODO: evaluate constants should probably be a participant
-        let (index, unresolvables) = plc::resolver::const_evaluator::evaluate_constants(global_index);
+        let (mut index, unresolvables) = plc::resolver::const_evaluator::evaluate_constants(global_index);
+
+        // Fix up enum defaults after constants are resolved
+        index.finalize_enum_defaults();
+
         IndexedProject { project: ParsedProject { units }, index, unresolvables }
     }
 }

src/index.rs

@@ -2025,6 +2025,59 @@ impl Index {
         self.type_index.pou_types.insert(datatype.get_name().to_lowercase(), datatype);
     }
 
+    /// Fixes up enum types to set their default initial values.
+    /// This must be called after constant resolution, as it needs to evaluate
+    /// constant expressions to determine which variant is zero.
+    ///
+    /// For each enum without an explicit initializer, this sets the initial_value to:
+    /// 1. The zero-variant (if one exists), or
+    /// 2. The first variant (as fallback)
+    pub fn finalize_enum_defaults(&mut self) {
+        // Process all types and update enum defaults
+        let mut fixed_types = Vec::new();
+
+        for (name, mut datatypes) in self.type_index.types.drain(..) {
+            for mut datatype in datatypes.drain(..) {
+                if let DataTypeInformation::Enum { variants, .. } = &datatype.information {
+                    // Only process if there's no explicit initializer
+                    if datatype.initial_value.is_none() && !variants.is_empty() {
+                        let mut zero_variant_id: Option<ConstId> = None;
+                        let mut first_variant_id: Option<ConstId> = None;
+
+                        // Look for a variant that evaluates to zero, or use the first one
+                        for (idx, variant) in variants.iter().enumerate() {
+                            if let Some(variant_init) = variant.initial_value {
+                                if idx == 0 {
+                                    first_variant_id = Some(variant_init);
+                                }
+
+                                if let Ok(0) =
+                                    self.constant_expressions.get_constant_int_statement_value(&variant_init)
+                                {
+                                    zero_variant_id = Some(variant_init);
+                                    break;
+                                }
+                            }
+                        }
+
+                        // Prefer zero variant, fall back to first variant
+                        let default_value = zero_variant_id.or(first_variant_id);
+                        if let Some(const_id) = default_value {
+                            datatype.initial_value = Some(const_id);
+                        }
+                    }
+                }
+
+                fixed_types.push((name.clone(), datatype));
+            }
+        }
+
+        // Re-insert all types
+        for (name, datatype) in fixed_types {
+            self.type_index.types.insert(name, datatype);
+        }
+    }
+
     pub fn find_callable_instance_variable(
         &self,
         context: Option<&str>,

src/index/indexer/user_type_indexer.rs

@@ -292,10 +292,8 @@ 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 (idx, ele) in flatten_expression_list(elements).iter().enumerate() {
+        for ele in flatten_expression_list(elements) {
             let variant = get_enum_element_name(ele);
             if let AstStatement::Assignment(Assignment { right, .. }) = ele.get_stmt() {
                 let scope = self.current_scope();
@@ -306,16 +304,6 @@ 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,
@@ -327,17 +315,6 @@ 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/test_utils.rs

@@ -141,6 +141,8 @@ pub mod tests {
         id_provider: IdProvider,
     ) -> Lowered {
         let (mut index, _) = evaluate_constants(index);
+        index.finalize_enum_defaults();
+
         let mut all_annotations = AnnotationMapImpl::default();
 
         let (mut annotations, ..) = TypeAnnotator::visit_unit(&index, &unit, id_provider.clone());
@@ -302,6 +304,7 @@ pub mod tests {
             },
         );
         let (mut index, ..) = evaluate_constants(index);
+        index.finalize_enum_defaults();
         let mut all_annotations = AnnotationMapImpl::default();
         let units = units
             .into_iter()

tests/lit/single/enums/enum_ensure_zero_variant_initializer_works_with_constant_variables.st

@@ -0,0 +1,32 @@
+// RUN: (%COMPILE %s && %RUN) | %CHECK %s
+
+VAR_GLOBAL CONSTANT
+    MYCONST: INT := 0;
+END_VAR
+
+// Test enum with no explicit default and a zero variant that is NOT also the first variant - BUT instead of a literal use a constant to initialize
+TYPE Status : INT (
+    active := 1,
+    inactive := MYCONST,
+    error := 2
+);
+END_TYPE
+
+VAR_GLOBAL
+    s_global: Status;  // Should initialize to inactive
+END_VAR
+
+PROGRAM prog
+VAR
+    s1 : Status;  // Should initialize to inactive
+END_VAR
+    // CHECK: 0
+    printf('%d$N', s1);  // inactive
+
+    // CHECK: 0
+    printf('%d$N', s_global);  // inactive
+END_PROGRAM
+
+FUNCTION main
+    prog();
+END_FUNCTION