wip

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -551,6 +551,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 {

compiler/plc_lowering/src/initializer.rs

@@ -20,8 +20,18 @@
 //! - Built-in types and variables are not re-initialized in the global
 //! constructor.
 
-use plc::index::{FxIndexMap, Index};
-use plc_ast::{ast::AstNode, mut_visitor::AstVisitorMut, visitor::AstVisitor};
+use std::any::Any;
+
+use plc::{
+    index::{FxIndexMap, Index},
+    lowering::helper::create_assignment,
+};
+use plc_ast::{
+    ast::{AstFactory, AstNode, CompilationUnit},
+    mut_visitor::AstVisitorMut,
+    provider::IdProvider,
+    visitor::AstVisitor,
+};
 
 #[derive(Debug, PartialEq)]
 enum Body {
@@ -31,20 +41,20 @@ enum Body {
 }
 
 pub struct Initializer<'idx> {
+    id_provider: IdProvider,
     index: &'idx Index,
     /// Stateful constructor per POU/struct
     constructors: FxIndexMap<String, Body>,
     /// Constructors for temp and stack variables per POU
-    stack_constructor: FxIndexMap<String, Vec<AstNode>>,
+    stack_constructor: FxIndexMap<String, Body>,
     /// Global constructor statements
     global_constructor: Vec<AstNode>,
 }
 
 //TODO: might need to be a mutable ast visitor
-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![],
+impl AstVisitor for Initializer<'_> {
+    fn visit_pou(&mut self, pou: &plc_ast::ast::Pou) {
+        match pou.linkage {
             plc_ast::ast::LinkageType::External => {
                 self.constructors.insert(pou.name.clone(), Body::External);
                 return;
@@ -53,36 +63,69 @@ impl AstVisitorMut for Initializer<'_> {
                 self.constructors.insert(pou.name.clone(), Body::None);
                 return;
             }
+            _ => {}
         };
 
+        let mut constructor = vec![];
+        let mut stack_constructor = vec![];
+
         // Collect variable initializers
-        for var in pou.variable_blocks.iter_mut() {}
+        for var in pou.variable_blocks.iter() {
+            for variable in var.variables.iter() {
+                if let Some(initializer) = &variable.initializer {
+                    // Create an assignment "self.<variable.name> := <initializer>"
+                    let assignment = create_assignment(
+                        variable.get_name(),
+                        Some("self"),
+                        initializer,
+                        self.id_provider.clone(),
+                    );
+                    if var.is_temp() || (var.is_local() && !pou.is_stateful()) {
+                        stack_constructor.push(assignment);
+                    } else {
+                        constructor.push(assignment);
+                    }
+                }
+            }
+        }
 
         self.constructors.insert(pou.name.clone(), Body::Internal(constructor));
+        self.stack_constructor.insert(pou.name.clone(), Body::Internal(stack_constructor));
     }
 
-    fn visit_user_type_declaration(&mut self, user_type: &mut plc_ast::ast::UserTypeDeclaration) {}
+    fn visit_user_type_declaration(&mut self, user_type: &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
-    }
+    fn visit_variable_block(&mut self, var_block: &plc_ast::ast::VariableBlock) {}
 }
 
 impl Initializer<'_> {
-    pub fn new(index: &Index) -> Initializer<'_> {
-        Initializer { index, constructors: FxIndexMap::default(), global_constructor: Vec::new() }
+    pub fn new(id_provider: IdProvider, index: &Index) -> Initializer<'_> {
+        Initializer {
+            id_provider,
+            index,
+            constructors: FxIndexMap::default(),
+            stack_constructor: FxIndexMap::default(),
+            global_constructor: Vec::new(),
+        }
     }
 }
 
 mod tests {
-    use plc_ast::visitor::AstVisitor;
+    use plc_ast::{ast::AstNode, visitor::AstVisitor};
     use plc_diagnostics::diagnostician::Diagnostician;
 
+    fn print_to_string(nodes: &[AstNode]) -> String {
+        nodes.iter().map(|it| it.as_string()).collect::<Vec<_>>().join("\n")
+    }
+
+    fn print_body_to_string(body: &super::Body) -> String {
+        match body {
+            super::Body::Internal(nodes) => print_to_string(nodes),
+            super::Body::External => "extern".to_string(),
+            super::Body::None => "none".to_string(),
+        }
+    }
+
     #[test]
     fn struct_gets_imlicit_initializer_and_constructor() {
         let src = r#"
@@ -99,13 +142,13 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
         // Expecting assignments inside the constructor: self->a = 5; self->b = 3.14; self->c = 1;
-        insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -128,18 +171,18 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
         // Expecting assignments inside the constructor: self->x = 10; self->y = 20;
-        insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("InnerStruct").unwrap()), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
         // Expecting a call to InnerStruct_ctor(&self->inner);
         // Expecting an assignment: self->z = 2.71;
-        insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("OuterStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -163,21 +206,21 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
         // Expecting assignments inside the constructor: self->x = 10; self->y = 20;
-        insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("InnerStruct").unwrap()), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
         // 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#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("OuterStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -200,15 +243,15 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for constructor
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
         // 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#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -227,18 +270,18 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Expecting a function declaration: void MyEnum_ctor(MyEnum* self)
         // Expecting an assignment inside the constructor: *self = 2;
-        insta::assert_debug_snapshot!(initializer.constructors.get("MyEnum"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyEnum").unwrap()), @r#""#);
         // Expecting a function declaration: void MyStruct_ctor(MyStruct* self)
         // 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#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -274,20 +317,20 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for constructors
         // Expecting a function declaration: void InnerStruct_ctor(InnerStruct* self)
         // Expecting assignments inside the constructor: self->a = 1; self->b = &gVar;
-        insta::assert_debug_snapshot!(initializer.constructors.get("InnerStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("InnerStruct").unwrap()), @r#""#);
         // Expecting a function declaration: void InnerStruct2_ctor(InnerStruct2* self)
         // Expecting a call to InnerStruct_ctor(&self->inner);
         // Expecting a call to InnerStruct_ctor(&self->inner2);
         // 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#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("InnerStruct2").unwrap()), @r#""#);
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
         // Expecting a call to InnerStruct2_ctor(&self->inner);
         // Expecting a call to InnerStruct2_ctor(&self->inner2);
@@ -296,7 +339,7 @@ mod tests {
         // 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 = &gVar;
         // Expecting assignments: self->inner3.inner.a = 9;
-        insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("OuterStruct").unwrap()), @r#""#);
     }
 
     #[test]
@@ -321,13 +364,13 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for global constructor
         // Expecting a call to MyStruct_ctor(&gStructVar);
-        insta::assert_debug_snapshot!(initializer.global_constructor, @r#""#);
+        insta::assert_debug_snapshot!(print_to_string(&initializer.global_constructor), @r#""#);
     }
 
     #[test]
@@ -351,13 +394,47 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
+        for unit in &project.units {
+            initializer.visit_compilation_unit(unit.get_unit());
+        }
+        // Check for function constructor on the stack
+        // Expecting a call to MyStruct_ctor(&localStruct);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.stack_constructor.get("MyFunction").unwrap()), @r#""#);
+    }
+
+    #[test]
+    fn program_temp_variables_are_in_stack_constructor() {
+        let src = r#"
+        PROGRAM MyProgram
+        VAR_TEMP
+            tempStruct : MyStruct;
+        END_VAR
+        VAR
+            localStruct : MyStruct;
+        END_VAR
+
+        TYPE MyStruct : STRUCT
+            a : INT := 5;
+            b : BOOL := TRUE;
+        END_STRUCT
+        "#;
+
+        let diagnostician = Diagnostician::buffered();
+        let mut pipeline =
+            plc_driver::pipelines::BuildPipeline::from_sources("test.st", vec![(src)], diagnostician)
+                .unwrap();
+        let project = pipeline.parse_and_annotate().unwrap();
+        // Visit the AST with the Initializer
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
-        // Check for function constructor
+        // Check for program constructor on the stack
         // Expecting a call to MyStruct_ctor(&localStruct);
-        insta::assert_debug_snapshot!(initializer.constructors.get("MyFunction"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.stack_constructor.get("MyProgram").unwrap()), @r#""#);
+        // Check for program constructor
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyProgram").unwrap()), @r#""#);
     }
 
     #[test]
@@ -375,13 +452,13 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for program constructor
         // Expecting a call to MyProgram_ctor(&progStruct);
-        insta::assert_debug_snapshot!(initializer.global_constructor, @r#""#);
+        insta::assert_debug_snapshot!(print_to_string(&initializer.global_constructor), @r#""#);
     }
 
     #[test]
@@ -409,15 +486,15 @@ mod tests {
                 .unwrap();
         let project = pipeline.parse_and_annotate().unwrap();
         // Visit the AST with the Initializer
-        let mut initializer = super::Initializer::new(&project.index);
+        let mut initializer = super::Initializer::new(pipeline.context.provider(), &project.index);
         for unit in &project.units {
             initializer.visit_compilation_unit(unit.get_unit());
         }
         // Check for internal var assignment in global constructor
         // Expecting a call to MyExtStruct_ctor(&internalVar);
         // No call to MyExtStruct_ctor(&extVar);
-        insta::assert_debug_snapshot!(initializer.global_constructor, @r#""#);
+        insta::assert_debug_snapshot!(print_to_string(&initializer.global_constructor), @r#""#);
         // Check that no constructor is generated for MyExtStruct
-        insta::assert_debug_snapshot!(initializer.constructors.get("MyExtStruct"), @r#""#);
+        insta::assert_debug_snapshot!(print_body_to_string(initializer.constructors.get("MyExtStruct").unwrap()), @r#""#);
     }
 }