feat!: rework initializers

Author: ghaith

Cargo.lock

@@ -0,0 +1,137 @@
+# Initializer Implementation Status
+
+## Overview
+
+The goal is for each datatype/POU to get a constructor (`<TypeName>_ctor`), and then a global constructor is created with calls to all constructors in the unit.
+
+## Current Implementation
+
+### What's Already Created (in `plc_lowering/src/initializer.rs`)
+
+#### 1. Per-Type Constructors (`<TypeName>_ctor`)
+- [x] Collects constructor body statements for each POU and struct
+- [x] Tracks `Body::Internal`, `Body::External`, or `Body::None` per type
+- [x] Generates assignment statements (`self.field := value`) for variables with initializers
+- [x] Handles nested struct initializers
+- [x] Generates call to user-defined `FB_INIT` method if present
+- [x] Creates the constructor POU and Implementation AST nodes via `new_constructor()`
+- [x] Adds constructors to the CompilationUnit
+
+#### 2. Stack Constructors (for temp/local variables in stateless POUs)
+- [x] Tracks per-POU (`stack_constructor` map)
+- [x] Applied to function bodies
+
+#### 3. Global Constructor Statements
+- [x] Collects statements for global variables into `global_constructor` Vec
+- [x] Generated statements for global initializers
+
+---
+
+## What's Missing
+
+### 4. Features from Old Implementation Not Yet Ported
+
+Comparing old `InitVisitor` (in `src/lowering/init_visitor.rs` + `src/lowering/initializers.rs`) vs new `Initializer`:
+
+| Feature | Old (`InitVisitor`) | New (`Initializer`) |
+|---------|---------------------|---------------------|
+| Type constructors (`__init_<type>`) | Done | Done (`<type>_ctor`) |
+| User init functions (`__user_init_<type>`) | Done | Missing |
+| Global wrapper (`__init___<project>`) | Done | Missing |
+| VAR_CONFIG init | Done | Missing |
+| VTable init in constructor | Done | Missing |
+| Stack var init in functions | Done | Collected but not applied |
+| External linkage handling | Done | Done |
+
+---
+
+## Implementation Plan
+
+### Step 1: Generate Global Constructor
+
+In `apply_initialization()`, after adding all type constructors:
+
+```rust
+// Create __global_ctor function
+if !self.global_constructor.is_empty() {
+    let mut global_ctor_body = vec![];
+
+    // Add calls to constructors for global struct instances
+    for (var_name, var_type) in global_struct_instances {
+        if self.constructors.contains_key(&var_type) {
+            let call = create_call_statement(
+                &format!("{}_ctor", var_type),
+                var_name,
+                None,
+                self.id_provider.clone(),
+                &SourceLocation::internal(),
+            );
+            global_ctor_body.push(call);
+        }
+    }
+
+    // Add collected assignment statements
+    global_ctor_body.extend(self.global_constructor);
+
+    // Create the POU and implementation
+    let (pou, impl) = new_global_constructor("__global_ctor", global_ctor_body, ...);
+    unit.pous.push(pou);
+    unit.implementations.push(impl);
+}
+```
+
+### Step 2: Apply Stack Constructors
+
+Modify function implementations to include stack initialization:
+
+```rust
+// For each implementation in unit.implementations
+for impl in &mut unit.implementations {
+    if let Some(Body::Internal(stmts)) = self.stack_constructor.get(&impl.name) {
+        // Prepend stack constructor statements to the implementation body
+        let mut new_body = stmts.clone();
+        new_body.extend(impl.statements.drain(..));
+        impl.statements = new_body;
+    }
+}
+```
+
+### Step 3: Ensure Constructor Call Chain
+
+In `visit_variable()`, verify that for struct-typed variables:
+1. First, call the struct's constructor: `<StructType>_ctor(self.var_name)`
+2. Then, apply any field overrides from the initializer
+
+### Step 4: Port Remaining Features
+
+1. **VTable initialization:** Add `self.__vtable := ADR(__vtable_<type>_instance)` to constructor body for classes/FBs
+2. **User init functions:** Generate `__user_init_<type>` that calls `FB_INIT` if present
+3. **VAR_CONFIG init:** Handle VAR_CONFIG initialization in global constructor
+
+---
+
+## Files to Modify
+
+- `compiler/plc_lowering/src/initializer.rs` - Main implementation
+- `src/lowering/helper.rs` - May need additional helper functions
+- `compiler/plc_driver/src/pipelines/participant.rs` - InitParticipant integration
+
+## Testing
+
+Existing tests in `compiler/plc_lowering/src/initializer.rs` cover:
+- Struct constructors
+- Nested structs
+- Pointer initializers
+- Enum defaults
+- Global constructor collection
+- Function/program constructors
+- External types
+- FB_INIT calls
+- Inheritance chains
+
+Additional tests needed:
+- [ ] Global constructor function generation
+- [ ] Stack constructor application to function bodies
+- [ ] Constructor call chain for nested structs
+- [ ] VTable initialization
+- [ ] Integration with codegen (actual LLVM output)

TODO.md

@@ -296,6 +296,26 @@ impl Pou {
     pub fn is_generic(&self) -> bool {
         !self.generics.is_empty()
     }
+
+    pub fn is_stateful(&self) -> bool {
+        matches!(self.kind, PouType::Program | PouType::FunctionBlock | PouType::Action | PouType::Class)
+    }
+
+    pub fn is_external(&self) -> bool {
+        matches!(self.linkage, LinkageType::External)
+    }
+
+    pub fn is_built_in(&self) -> bool {
+        matches!(self.linkage, LinkageType::BuiltIn)
+    }
+
+    pub fn is_function_block(&self) -> bool {
+        matches!(self.kind, PouType::FunctionBlock)
+    }
+
+    pub fn is_class(&self) -> bool {
+        matches!(self.kind, PouType::Class)
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -313,11 +333,19 @@ pub struct Implementation {
     pub access: Option<AccessModifier>,
 }
 
+/// Marks declaration and linking requirements for an ast member
 #[derive(Debug, Copy, PartialEq, Eq, Clone, Hash)]
 pub enum LinkageType {
+    /// The element is declared in the project currently being complied
     Internal,
+    /// The element is declared externally and being used by the project
     External,
+    /// This indicates an element that should not have any declarations within the compiled project
+    /// For example a built in function is implied to exist but not declared
     BuiltIn,
+    // TODO: A private linkage indicates an internal element that should not be visible externally
+    // This is for example a static constructor that should not leak outside its module
+    // Private,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -480,6 +508,19 @@ pub enum VariableBlockType {
     InOut,
     External,
 }
+impl VariableBlockType {
+    pub fn is_temp(&self) -> bool {
+        matches!(self, VariableBlockType::Temp)
+    }
+
+    pub fn is_local(&self) -> bool {
+        matches!(self, VariableBlockType::Local)
+    }
+
+    pub fn is_global(&self) -> bool {
+        matches!(self, VariableBlockType::Global)
+    }
+}
 
 impl Display for VariableBlockType {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -517,6 +558,11 @@ impl VariableBlock {
         VariableBlock::default().with_block_type(VariableBlockType::Global)
     }
 
+    pub fn with_linkage(mut self, linkage: LinkageType) -> Self {
+        self.linkage = linkage;
+        self
+    }
+
     pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
         self.kind = block_type;
         self
@@ -526,6 +572,14 @@ impl VariableBlock {
         self.variables = variables;
         self
     }
+
+    pub fn is_local(&self) -> bool {
+        matches!(self.kind, VariableBlockType::Local)
+    }
+
+    pub fn is_temp(&self) -> bool {
+        matches!(self.kind, VariableBlockType::Temp)
+    }
 }
 
 impl Default for VariableBlock {
@@ -640,9 +694,9 @@ impl DataTypeDeclaration {
         }
     }
 
-    pub fn get_referenced_type(&self) -> Option<String> {
+    pub fn get_referenced_type(&self) -> Option<&str> {
         let DataTypeDeclaration::Reference { referenced_type, .. } = self else { return None };
-        Some(referenced_type.to_owned())
+        Some(referenced_type.as_str())
     }
 
     pub fn get_inner_pointer_ty(&self) -> Option<DataTypeDeclaration> {
@@ -679,6 +733,7 @@ pub struct UserTypeDeclaration {
     pub location: SourceLocation,
     /// stores the original scope for compiler-generated types
     pub scope: Option<String>,
+    pub linkage: LinkageType,
 }
 
 impl Debug for UserTypeDeclaration {
@@ -804,6 +859,10 @@ impl DataType {
     pub fn is_type_safe_pointer(&self) -> bool {
         matches!(self, DataType::PointerType { type_safe: true, .. })
     }
+
+    pub fn is_generic(&self) -> bool {
+        matches!(self, DataType::GenericType { .. })
+    }
 }
 
 fn replace_reference(

compiler/plc_ast/src/ast.rs

@@ -61,8 +61,13 @@ pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
                     if let DataTypeDeclaration::Definition { mut data_type, location, scope } = *datatype {
                         data_type.set_name(type_name);
                         add_nested_datatypes(name, &mut data_type, &mut new_types, &location);
-                        let data_type =
-                            UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope };
+                        let data_type = UserTypeDeclaration {
+                            data_type: *data_type,
+                            initializer: None,
+                            location,
+                            scope,
+                            linkage: crate::ast::LinkageType::Internal,
+                        };
                         new_types.push(data_type);
                     }
                 }
@@ -289,6 +294,7 @@ fn preprocess_generic_structs(pou: &mut Pou) -> Vec<UserTypeDeclaration> {
             initializer: None,
             scope: Some(pou.name.clone()),
             location: pou.location.clone(),
+            linkage: crate::ast::LinkageType::Internal,
         };
         types.push(data_type);
         generic_types.insert(binding.name.clone(), new_name);
@@ -314,8 +320,13 @@ fn preprocess_return_type(pou: &mut Pou, types: &mut Vec<UserTypeDeclaration>) {
             if let Some(DataTypeDeclaration::Definition { mut data_type, location, scope }) = datatype {
                 data_type.set_name(type_name);
                 add_nested_datatypes(pou.name.as_str(), &mut data_type, types, &location);
-                let data_type =
-                    UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope };
+                let data_type = UserTypeDeclaration {
+                    data_type: *data_type,
+                    initializer: None,
+                    location,
+                    scope,
+                    linkage: crate::ast::LinkageType::Internal,
+                };
                 types.push(data_type);
             }
         }
@@ -350,7 +361,13 @@ fn pre_process_variable_data_type(
         // create index entry
         add_nested_datatypes(new_type_name.as_str(), &mut data_type, types, &location);
         data_type.set_name(new_type_name);
-        types.push(UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope });
+        types.push(UserTypeDeclaration {
+            data_type: *data_type,
+            initializer: None,
+            location,
+            scope,
+            linkage: crate::ast::LinkageType::Internal,
+        });
     }
     //make sure it gets generated
 }
@@ -379,6 +396,7 @@ fn add_nested_datatypes(
             initializer: None,
             location: location.clone(),
             scope,
+            linkage: crate::ast::LinkageType::Internal,
         });
     }
 }

compiler/plc_ast/src/pre_processor.rs

@@ -1,4 +1,5 @@
 use std::{
+    backtrace,
     fmt::Display,
     ops::{Deref, DerefMut},
 };
@@ -276,6 +277,7 @@ impl Diagnostic {
     where
         T: Into<SourceLocation>,
     {
+        panic!("Unresolved reference to {}", reference);
         Diagnostic::new(format!("Could not resolve reference to {reference:}"))
             .with_error_code("E048")
             .with_location(location)
@@ -303,6 +305,7 @@ impl Diagnostic {
 
     pub fn cannot_generate_call_statement(operator: &AstNode) -> Diagnostic {
         //TODO: We could probably get a better slice here
+        panic!("Cannot generate call statement for {:?}", operator);
         Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
     }