wip: lowered ast

Author: ghaith

compiler/plc_lowering/src/initializer.rs

@@ -27,7 +27,7 @@
 use plc::index::{FxIndexMap, Index};
 use plc_ast::{ast::AstNode, visitor::AstVisitor};
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 enum Body {
     Internal(Vec<AstNode>),
     External,
@@ -147,6 +147,7 @@ mod tests {
 
         TYPE OuterStruct : STRUCT
             inner : InnerStruct := (x := 1, y := 2);
+            inner2 : InnerStruct := (y := 3);
             z : REAL := 2.71;
         END_STRUCT
         "#;
@@ -164,7 +165,7 @@ mod tests {
         // 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 = {1, 2, 2.71};
+        // 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)
@@ -174,17 +175,270 @@ mod tests {
         // Expecting a function declaration: void OuterStruct_ctor(OuterStruct* self)
         // Expecting a call to memcpy inside the constructor: memcpy(self, &OuterStruct_init,
         // sizeof(OuterStruct));
-        // TODO: how do we prevent this from overriding the set values?
         // 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;
         insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
     }
 
     #[test]
-    fn variable_with_pointer_initializer_is_added_to_constructor() {}
+    fn variable_with_pointer_initializer_is_added_to_constructor() {
+        let src = r#"
+        VAR_GLOBAL
+            gVar : INT;
+            myStructVar : MyStruct;
+        END_VAR
+        TYPE MyStruct : STRUCT
+            a : INT := 5;
+            b : POINTER TO INT := ADR(gVar);
+            c : 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(&project.index);
+        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 an assignment: self->b = &gVar;
+        insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
+    }
 
     #[test]
-    fn enum_default_values_in_struct() {}
+    fn enum_default_values_in_struct() {
+        let src = r#"
+        TYPE MyEnum : (Option1, Option2, Option3) := Option3;
+        TYPE MyStruct : STRUCT
+            e : MyEnum := Option2;
+            n : INT := 42;
+        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(&project.index);
+        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;
+        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;
+        insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
+    }
 
     #[test]
-    fn nested_struct_with_different_default_values() {}
+    fn nested_struct_with_different_default_values() {
+        let src = r#"
+        TYPE InnerStruct : STRUCT
+            a : INT := 1;
+            b : POINTER TO INT := ADR(a);
+        END_STRUCT
+
+        TYPE InnerStruct2 : STRUCT
+            c : INT := 4;
+            d : INT := 5;
+            inner : InnerStruct := (a := 6);
+            inner2 : InnerStruct := (b := ADR(c));
+        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)));
+            inner3 : InnerStruct2 := (inner (a := 9));
+        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(&project.index);
+        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;
+        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;
+        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 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->inner3.inner.a = 9;
+        insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
+    }
+
+    #[test]
+    fn global_constructor_is_generated() {
+        let src = r#"
+        VAR_GLOBAL
+            gVar1 : INT := 10;
+            gVar2 : REAL;
+            gStructVar : MyStruct;
+        END_VAR
+
+        TYPE MyStruct : STRUCT
+            a : INT := 5;
+            b : POINTER TO INT := ADR(gVar1);
+            c : 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(&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#""#);
+    }
+
+    #[test]
+    fn function_constructors_have_the_function_name() {
+        let src = r#"
+        FUNCTION MyFunction : INT
+        VAR
+            localStruct : MyStruct;
+        END_VAR
+        END_FUNCTION
+
+        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(&project.index);
+        for unit in &project.units {
+            initializer.visit_compilation_unit(unit.get_unit());
+        }
+        // Check for function constructor
+        // Expecting a call to MyStruct_ctor(&localStruct);
+        insta::assert_debug_snapshot!(initializer.constructors.get("MyFunction"), @r#""#);
+    }
+
+    #[test]
+    fn programs_are_globals() {
+        let src = r#"
+        PROGRAM MyProgram
+        VAR
+        END_VAR
+        END_PROGRAM
+        "#;
+
+        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(&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#""#);
+    }
+
+    #[test]
+    fn external_structs_and_variables_are_not_initialized() {
+        let src = r#"
+        VAR_GLOBAL
+            internalVar : MyExtStruct;
+        END_VAR
+
+        {external}
+        VAR_GLOBAL
+            extVar : MyExtStruct;
+        END_VAR
+
+        {external}
+        TYPE MyExtStruct : 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(&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#""#);
+        // Check that no implicit initializer or constructor is generated for MyExtStruct
+        assert_eq!(initializer.implicit_initializers.get("MyExtStruct"), None);
+        insta::assert_debug_snapshot!(initializer.constructors.get("MyExtStruct"), @r#""#);
+    }
 }

compiler/plc_lowering/src/lib.rs

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

compiler/plc_lowering/src/lower_ast.rs

@@ -0,0 +1,34 @@
+//! A low level representation of the AST
+//! This module defines a lower-level representation of the Abstract Syntax Tree (AST)
+//! it defines only simple data structures without any complex logic
+
+pub struct LoweredAst {
+    nodes: Vec<LoweredNode>,
+}
+
+pub enum LoweredNode {
+    TypeDef(TypeDef),
+    TypeNode(TypeNode),
+    Variable,
+    Declaration,
+    Assignment,
+    Call,
+    Return,
+}
+
+pub struct TypeDef {
+    name: String,
+    target: String,
+}
+
+pub struct TypeNode {
+    name: String,
+    size: usize,
+    elements: Vec<TypeNode>,
+}
+
+pub struct Variable {
+    name: String,
+    var_type: String,
+    value: Vec<String>,
+}