remove the lowered ast, stick to normal ast for now

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -300,6 +300,14 @@ impl Pou {
     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)
+    }
 }
 
 #[derive(Debug, PartialEq)]

compiler/plc_lowering/src/initializer.rs

@@ -5,14 +5,10 @@
 //! to include initialization code, making sure that the resulting AST is ready for
 //! further compilation stages.
 //! Initialization logic is as follows:
-//! - Every struct(and POU) has an optional implicit initializer for constant fields.
-//!     - The name for this initializer is `<StructName>_init`
-//!     - The field is always private to the module
-//! - Every struct(and POU) has a constructor for fields with pointer assignments or non-constant values
+//! - Every struct(and POU) has a constructor for fields with constant or pointer initializers.
 //!    - The name for this constructor is `<StructName>_ctor`
-//!    - The constructor is always public and implicitly uses the implicit initializer
-//! - Variables of the struct are initialized using the implicit initializer if their value is
-//!   derived at compile time, otherwise the constructor is used.
+//!    - The constructor is always public
+//! - Variables of the struct are initialized by calling the constructor
 //! - Global variables are initialized in a global constructor function called `__global_ctor`
 //!   - This function is called per module inside the static initialization code
 //!   - The function is private to the module
@@ -21,11 +17,11 @@
 //! - External POUs and struct constructors are marked as `extern` and have no body.
 //! - External variables are not re-initialized in the global constructor, they are assumed to be
 //!   initialized externally.
-//! - Bulit-in types and variables are not re-initialized in the global
+//! - Built-in types and variables are not re-initialized in the global
 //! constructor.
 
 use plc::index::{FxIndexMap, Index};
-use plc_ast::{ast::AstNode, visitor::AstVisitor};
+use plc_ast::{ast::AstNode, mut_visitor::AstVisitorMut, visitor::AstVisitor};
 
 #[derive(Debug, PartialEq)]
 enum Body {
@@ -36,29 +32,50 @@ enum Body {
 
 pub struct Initializer<'idx> {
     index: &'idx Index,
-    implicit_initializers: FxIndexMap<String, Body>,
+    /// Stateful constructor per POU/struct
     constructors: FxIndexMap<String, Body>,
+    /// Constructors for temp and stack variables per POU
+    stack_constructor: FxIndexMap<String, Vec<AstNode>>,
+    /// Global constructor statements
     global_constructor: Vec<AstNode>,
 }
 
 //TODO: might need to be a mutable ast visitor
-impl AstVisitor for Initializer<'_> {
-    fn visit_compilation_unit(&mut self, unit: &plc_ast::ast::CompilationUnit) {
-        // Read all structs and POU structs, collect their implicit initializers if available
-        // Add a call to the constructor to memcpy the imlicit initializer
+impl AstVisitorMut for Initializer<'_> {
+    fn visit_pou(&mut self, pou: &mut plc_ast::ast::Pou) {
+        let constructor = match pou.linkage {
+            plc_ast::ast::LinkageType::Internal => vec![],
+            plc_ast::ast::LinkageType::External => {
+                self.constructors.insert(pou.name.clone(), Body::External);
+                return;
+            }
+            plc_ast::ast::LinkageType::BuiltIn => {
+                self.constructors.insert(pou.name.clone(), Body::None);
+                return;
+            }
+        };
+
+        // Collect variable initializers
+        for var in pou.variable_blocks.iter_mut() {}
+
+        self.constructors.insert(pou.name.clone(), Body::Internal(constructor));
+    }
+
+    fn visit_user_type_declaration(&mut self, user_type: &mut plc_ast::ast::UserTypeDeclaration) {}
+
+    fn visit_variable_block(&mut self, var_block: &mut plc_ast::ast::VariableBlock) {}
+
+    fn visit_compilation_unit(&mut self, unit: &mut plc_ast::ast::CompilationUnit) {
+        // Read all structs and POU structs
+        // Add a call to the constructor to initialize every variable
         // For each of the call statement or reference in the pou initializer, add an assignment to
         // the constructor
     }
 }
 
 impl Initializer<'_> {
     pub fn new(index: &Index) -> Initializer<'_> {
-        Initializer {
-            index,
-            implicit_initializers: FxIndexMap::default(),
-            constructors: FxIndexMap::default(),
-            global_constructor: Vec::new(),
-        }
+        Initializer { index, constructors: FxIndexMap::default(), global_constructor: Vec::new() }
     }
 }
 
@@ -86,13 +103,8 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializer
-        // Expecting a variable declaration: MyStruct MyStruct_init = {5, 3.14, TRUE};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("MyStruct"), @r#""#);
-        // Check for an empty constructor
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &MyStruct_init,
-        // sizeof(MyStruct));
+        // Expecting assignments inside the constructor: self->a = 5; self->b = 3.14; self->c = 1;
         insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
     }
 
@@ -120,20 +132,13 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializers
-        // Expecting a variable declaration: InnerStruct InnerStruct_init = {10, 20};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("InnerStruct"), @r#""#);
-        // Expecting a variable declaration: OuterStruct OuterStruct_init = {0, 0, 2.71};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("OuterStruct"), @r#""#);
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &InnerStruct_init,
-        // sizeof(InnerStruct));
+        // Expecting assignments inside the constructor: self->x = 10; self->y = 20;
         insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &OuterStruct_init,
-        // sizeof(OuterStruct));
         // Expecting a call to InnerStruct_ctor(&self->inner);
+        // Expecting an assignment: self->z = 2.71;
         insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
     }
 
@@ -162,23 +167,16 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializers
-        // Expecting a variable declaration: InnerStruct InnerStruct_init = {10, 20};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("InnerStruct"), @r#""#);
-        // Expecting a variable declaration: OuterStruct OuterStruct_init = {10, 20, 10, 20, 2.71};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("OuterStruct"), @r#""#);
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &InnerStruct_init,
-        // sizeof(InnerStruct));
+        // Expecting assignments inside the constructor: self->x = 10; self->y = 20;
         insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &OuterStruct_init,
-        // sizeof(OuterStruct));
         // Expecting a call to InnerStruct_ctor(&self->inner);
         // Expecting a call to InnerStruct_ctor(&self->inner2);
         // Expecting assignments: self->inner.x = 1; self->inner.y = 2;
         // Expecting assignments: self->inner2.y = 3;
+        // Expecting an assignment: self->z = 2.71;
         insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
     }
 
@@ -206,13 +204,9 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializers
-        // Expecting a variable declaration: MyStruct MyStruct_init = {5, 0, 1};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("MyStruct"), @r#""#);
         // Check for constructor
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &MyStruct_init,
-        // sizeof(MyStruct));
+        // Expecting assignments inside the constructor: self->a = 5; self->c = 1;
         // Expecting an assignment: self->b = &gVar;
         insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
     }
@@ -237,41 +231,39 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializer
-        // Expecting a variable declaration: MyEnum MyEnum_init = 2;
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("MyEnum"), @r#""#);
         // Expecting a function declaration: void MyEnum_ctor(MyEnum* self)
-        // Expecting an assignment inside the constructor: *self = MyEnum_init;
+        // Expecting an assignment inside the constructor: *self = 2;
         insta::assert_debug_snapshot!(initializer.constructors.get("MyEnum"), @r#""#);
-        // Expecting a variable declaration: MyStruct MyStruct_init = {3, 42};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("MyStruct"), @r#""#);
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &MyStruct_init,
-        // sizeof(MyStruct));
         // Expecting a call to MyEnum_ctor(&self->e);
         // Expecting an assignment: self->e = 1;
+        // Expecting an assignment: self->n = 42;
         insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
     }
 
     #[test]
     fn nested_struct_with_different_default_values() {
         let src = r#"
+        VAR_GLOBAL
+            gVar : INT := 10;
+        END_VAR
+
         TYPE InnerStruct : STRUCT
             a : INT := 1;
-            b : POINTER TO INT := ADR(a);
+            b : POINTER TO INT := ADR(gVar);
         END_STRUCT
 
         TYPE InnerStruct2 : STRUCT
             c : INT := 4;
             d : INT := 5;
             inner : InnerStruct := (a := 6);
-            inner2 : InnerStruct := (b := ADR(c));
+            inner2 : InnerStruct := (b := ADR(gVar));
         END_STRUCT
 
         TYPE OuterStruct : STRUCT
             e : INT := 0;
             inner : InnerStruct2 := (a := 1, b := 2, inner := (a := 3));
-            inner2 : InnerStruct2 := (d := 8, inner := (b := ADR(e)));
+            inner2 : InnerStruct2 := (d := 8, inner := (b := ADR(gVar)));
             inner3 : InnerStruct2 := (inner (a := 9));
         END_STRUCT
         "#;
@@ -286,35 +278,23 @@ mod tests {
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for implicit initializers
-        // Expecting a variable declaration: InnerStruct InnerStruct_init = {1, 0};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("InnerStruct"), @r#""#);
-        // Expecting a variable declaration: InnerStruct InnerStruct_init = {4, 5, 1, 0, 1, 0};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("InnerStruct2"), @r#""#);
-        // Expecting a variable declaration: OuterStruct OuterStruct_init = {0, 4, 5, 1, 0, 1, 0,
-        // 4, 5, 1, 0, 1, 0, 4, 5, 1, 0, 1, 0};
-        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("OuterStruct"), @r#""#);
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &InnerStruct_init,
-        // sizeof(InnerStruct));
-        // Expecting an assignment: self->b = &self->a;
+        // Expecting assignments inside the constructor: self->a = 1; self->b = &gVar;
         insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
         // Expecting a function declaration: void InnerStruct2_ctor(InnerStruct2* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &InnerStruct_init,
-        // sizeof(InnerStruct));
         // Expecting a call to InnerStruct_ctor(&self->inner);
         // Expecting a call to InnerStruct_ctor(&self->inner2);
-        // Expecting assignments: self->inner.a = 6; self->inner2.b = &self->c;
+        // Expecting assignments: self->c = 4; self->d = 5;
+        // Expecting assignments: self->inner.a = 6; self->inner2.b = &gvar;
         insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct2"), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
-        // Expecting a call to memcpy inside the constructor: memcpy(self, &OuterStruct_init,
-        // sizeof(OuterStruct));
         // Expecting a call to InnerStruct2_ctor(&self->inner);
         // Expecting a call to InnerStruct2_ctor(&self->inner2);
         // Expecting a call to InnerStruct2_ctor(&self->inner3);
+        // Expecting an assignment: self->e = 0;
         // Expecting assignments: self->inner.a = 1; self->inner.b = 2; self->inner.inner.a = 3;
-        // Expecting assignments: self->inner2.d = 8; self->inner2.inner.b = &self->e;
+        // Expecting assignments: self->inner2.d = 8; self->inner2.inner.b = &gVar;
         // Expecting assignments: self->inner3.inner.a = 9;
         insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
     }
@@ -437,8 +417,7 @@ mod tests {
         // Expecting a call to MyExtStruct_ctor(&internalVar);
         // No call to MyExtStruct_ctor(&extVar);
         insta::assert_debug_snapshot!(initializer.global_constructor, @r#""#);
-        // Check that no implicit initializer or constructor is generated for MyExtStruct
-        assert_eq!(initializer.implicit_initializers.get("MyExtStruct"), None);
+        // Check that no constructor is generated for MyExtStruct
         insta::assert_debug_snapshot!(initializer.constructors.get("MyExtStruct"), @r#""#);
     }
 }

compiler/plc_lowering/src/lib.rs

@@ -6,7 +6,6 @@ use plc_ast::{ast::AstNode, provider::IdProvider};
 
 pub mod inheritance;
 pub mod initializer;
-pub mod lower_ast;
 #[cfg(test)]
 mod tests;