add helper methods to create pipelines with custom particitants

Author: ghaith

Cargo.lock

@@ -156,7 +156,7 @@ pub fn compile_with_pipeline<T: SourceContainer + Clone + 'static>(
     mut pipeline: BuildPipeline<T>,
 ) -> Result<()> {
     //register participants
-    pipeline.register_default_participants();
+    pipeline.register_default_mut_participants();
     let target = pipeline.compile_parameters.as_ref().and_then(|it| it.target.clone()).unwrap_or_default();
     let codegen_participant = CodegenParticipant {
         compile_options: pipeline.get_compile_options().unwrap(),
@@ -192,35 +192,56 @@ pub fn parse_and_annotate<T: SourceContainer + Clone>(
     name: &str,
     src: Vec<T>,
 ) -> Result<(GlobalContext, AnnotatedProject), Diagnostic> {
-    let (pipeline, project) = parse_and_annotate_with_diagnostics(name, src, Diagnostician::buffered())
-        .map_err(|it| Diagnostic::new(it.buffer().unwrap_or_default()))?;
+    let (pipeline, project) = parse_and_annotate_with_diagnostics(name, src, Diagnostician::buffered())?;
     Ok((pipeline.context, project))
 }
 
+impl<T: SourceContainer> BuildPipeline<T> {
+    pub fn from_sources(name: &str, src: Vec<T>, diagnostician: Diagnostician) -> Result<Self, Diagnostic> {
+        // Parse the source to ast
+        let project = Project::new(name.to_string()).with_sources(src);
+        let Ok(context) = GlobalContext::new().with_source(project.get_sources(), None) else {
+            return Err(Diagnostic::new(diagnostician.buffer().unwrap_or_default()));
+        };
+        let pipeline = BuildPipeline {
+            context,
+            project,
+            diagnostician,
+            compile_parameters: None,
+            linker: LinkerType::Internal,
+            mutable_participants: Vec::default(),
+            participants: Vec::default(),
+            module_name: Some("<internal>".to_string()),
+        };
+        Ok(pipeline)
+    }
+
+    /// Parses, indexes and annotates the project, returning any diagnostics found along the way
+    /// Used for tests where we don't want to run the full pipeline
+    pub fn parse_and_annotate(&mut self) -> Result<AnnotatedProject, Diagnostic> {
+        let Ok(project) = self.parse() else {
+            return Err(Diagnostic::new(self.diagnostician.buffer().unwrap_or_default()));
+        };
+        let Ok(project) = self.index(project) else {
+            return Err(Diagnostic::new(self.diagnostician.buffer().unwrap_or_default()));
+        };
+        let Ok(project) = self.annotate(project) else {
+            return Err(Diagnostic::new(self.diagnostician.buffer().unwrap_or_default()));
+        };
+        Ok(project)
+    }
+}
+
 pub fn parse_and_annotate_with_diagnostics<T: SourceContainer + Clone>(
     name: &str,
     src: Vec<T>,
     diagnostician: Diagnostician,
-) -> Result<(BuildPipeline<T>, AnnotatedProject), Diagnostician> {
+) -> Result<(BuildPipeline<T>, AnnotatedProject), Diagnostic> {
     // Parse the source to ast
-    let project = Project::new(name.to_string()).with_sources(src);
-    let Ok(context) = GlobalContext::new().with_source(project.get_sources(), None) else {
-        return Err(diagnostician);
-    };
-    let mut pipeline = BuildPipeline {
-        context,
-        project,
-        diagnostician,
-        compile_parameters: None,
-        linker: LinkerType::Internal,
-        mutable_participants: Vec::default(),
-        participants: Vec::default(),
-        module_name: Some("<internal>".to_string()),
-    };
-    pipeline.register_default_participants();
-    let Ok(project) = pipeline.parse() else { return Err(pipeline.diagnostician) };
-    let Ok(project) = pipeline.index(project) else { return Err(pipeline.diagnostician) };
-    let Ok(project) = pipeline.annotate(project) else { return Err(pipeline.diagnostician) };
+    let mut pipeline = BuildPipeline::from_sources(name, src, diagnostician)?;
+    pipeline.register_default_mut_participants();
+    let project = pipeline.parse_and_annotate()?;
+    let _ = project.validate(&pipeline.context, &mut pipeline.diagnostician);
     Ok((pipeline, project))
 }
 
@@ -230,7 +251,7 @@ pub fn parse_and_validate<T: SourceContainer + Clone>(name: &str, src: Vec<T>) -
             let _ = project.validate(&pipeline.context, &mut pipeline.diagnostician);
             pipeline.diagnostician.buffer().unwrap()
         }
-        Err(diagnostician) => diagnostician.buffer().unwrap(),
+        Err(diagnostic) => diagnostic.to_string(),
     }
 }
 
@@ -266,7 +287,7 @@ fn generate_to_string_internal<T: SourceContainer>(
         participants: Vec::default(),
         module_name: Some("<internal>".to_string()),
     };
-    pipeline.register_default_participants();
+    pipeline.register_default_mut_participants();
     let project = pipeline.parse()?;
     let project = pipeline.index(project)?;
     let project = pipeline.annotate(project)?;

compiler/plc_driver/src/lib.rs

@@ -247,21 +247,28 @@ impl<T: SourceContainer> BuildPipeline<T> {
             log::info!("{err}")
         }
     }
-    /// Register all default participants (excluding codegen/linking)
-    pub fn register_default_participants(&mut self) {
+
+    pub fn get_default_mut_particitants(&self) -> Vec<Box<dyn PipelineParticipantMut>> {
         use participant::InitParticipant;
 
-        // XXX: should we use a static array of participants?
-        let mut_participants: Vec<Box<dyn PipelineParticipantMut>> = vec![
+        vec![
             Box::new(VirtualTableGenerator::new(self.context.provider())),
             Box::new(PolymorphicCallLowerer::new(self.context.provider())),
             Box::new(PropertyLowerer::new(self.context.provider())),
             Box::new(InitParticipant::new(self.project.get_init_symbol_name(), self.context.provider())),
             Box::new(AggregateTypeLowerer::new(self.context.provider())),
             Box::new(InheritanceLowerer::new(self.context.provider())),
-        ];
+        ]
+    }
+    /// Register all default participants (excluding codegen/linking)
+    pub fn register_default_mut_participants(&mut self) {
+        // XXX: should we use a static array of participants?
+        let mut_participants = self.get_default_mut_particitants();
+        self.register_mut_participants(mut_participants);
+    }
 
-        for participant in mut_participants {
+    pub fn register_mut_participants(&mut self, participants: Vec<Box<dyn PipelineParticipantMut>>) {
+        for participant in participants {
             self.register_mut_participant(participant)
         }
     }

compiler/plc_driver/src/pipelines.rs

@@ -43,7 +43,7 @@ pub fn compile<T: Compilable>(codegen_context: &CodegenContext, source: T) -> Ge
         module_name: Some("<internal>".to_string()),
     };
 
-    pipeline.register_default_participants();
+    pipeline.register_default_mut_participants();
 
     let project = pipeline.parse().unwrap();
     let project = pipeline.index(project).unwrap();

compiler/plc_driver/src/runner.rs

@@ -7,8 +7,9 @@ edition = "2021"
 plc = { path = "../..", package = "rusty" }
 plc_ast = { path = "../plc_ast" }
 plc_source = { path = "../plc_source" }
+plc_diagnostics = { path = "../plc_diagnostics" }
 log.workspace = true
 
 [dev-dependencies]
 plc_driver = { path = "../plc_driver" }
-insta = "1.31.0"
+insta = "1.31.0"

compiler/plc_lowering/Cargo.toml

@@ -27,6 +27,7 @@
 use plc::index::{FxIndexMap, Index};
 use plc_ast::{ast::AstNode, visitor::AstVisitor};
 
+#[derive(Debug)]
 enum Body {
     Internal(Vec<AstNode>),
     External,
@@ -44,12 +45,6 @@ pub struct Initializer<'idx> {
 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
-        unit.pous.iter().for_each(|pou| {
-            // find the pou index entry
-            if let Some(pie) = self.index.find_pou_type(&pou.name) {
-                pie.initial_value
-            }
-        });
         // Add a call to the constructor to memcpy the imlicit initializer
         // For each of the call statement or reference in the pou initializer, add an assignment to
         // the constructor
@@ -68,14 +63,121 @@ impl Initializer<'_> {
 }
 
 mod tests {
+    use plc_ast::visitor::AstVisitor;
+    use plc_diagnostics::diagnostician::Diagnostician;
+
     #[test]
-    fn struct_gets_imlicit_initializer_and_constructor() {}
+    fn struct_gets_imlicit_initializer_and_constructor() {
+        let src = r#"
+        TYPE MyStruct : STRUCT
+            a : INT := 5;
+            b : REAL := 3.14;
+            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 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));
+        insta::assert_debug_snapshot!(initializer.constructors.get("MyStruct"), @r#""#);
+    }
 
     #[test]
-    fn struct_gets_constructor() {}
+    fn nested_structs_get_initializers_and_constructors() {
+        let src = r#"
+        TYPE InnerStruct : STRUCT
+            x : INT := 10;
+            y : INT := 20;
+        END_STRUCT
+
+        TYPE OuterStruct : STRUCT
+            inner : InnerStruct;
+            z : REAL := 2.71;
+        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 = {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));
+        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);
+        insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
+    }
 
     #[test]
-    fn nested_structs_get_initializers_and_constructors() {}
+    fn nested_structs_with_values_get_initializers_and_constructors() {
+        let src = r#"
+        TYPE InnerStruct : STRUCT
+            x : INT := 10;
+            y : INT := 20;
+        END_STRUCT
+
+        TYPE OuterStruct : STRUCT
+            inner : InnerStruct := (x := 1, y := 2);
+            z : REAL := 2.71;
+        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 = {10, 20};
+        insta::assert_debug_snapshot!(initializer.implicit_initializers.get("InnerStruct"), @r#""#);
+        // Expecting a variable declaration: OuterStruct OuterStruct_init = {1, 2, 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));
+        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));
+        // TODO: how do we prevent this from overriding the set values?
+        // Expecting a call to InnerStruct_ctor(&self->inner);
+        insta::assert_debug_snapshot!(initializer.constructors.get("OuterStruct"), @r#""#);
+    }
 
     #[test]
     fn variable_with_pointer_initializer_is_added_to_constructor() {}

compiler/plc_lowering/src/initializer.rs

@@ -37,7 +37,7 @@ pub fn parse_and_validate_buffered_ast(src: &str) -> Vec<CompilationUnit> {
             project.validate(&pipeline.context, &mut pipeline.diagnostician).unwrap();
             project.units.into_iter().map(CompilationUnit::from).collect()
         }
-        Err(diagnostician) => panic!("{}", diagnostician.buffer().unwrap()),
+        Err(diagnostics) => panic!("{diagnostics}"),
     }
 }