feat: Support jumps and labels from CFC (#969)

* Add jump and label to AST

Add tests for the jump impls

* Add ast transformation for the jump and label controls

* Codegen and validation for jumps and labels

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -616,6 +616,8 @@ pub enum AstStatement {
     ExitStatement(()),
     ContinueStatement(()),
     ReturnStatement(ReturnStatement),
+    JumpStatement(JumpStatement),
+    LabelStatement(LabelStatement),
 }
 
 impl Debug for AstNode {
@@ -726,6 +728,12 @@ impl Debug for AstNode {
             AstStatement::ReferenceExpr(ReferenceExpr { access, base }) => {
                 f.debug_struct("ReferenceExpr").field("kind", access).field("base", base).finish()
             }
+            AstStatement::JumpStatement(JumpStatement { condition, target, .. }) => {
+                f.debug_struct("JumpStatement").field("condition", condition).field("target", target).finish()
+            }
+            AstStatement::LabelStatement(LabelStatement { name, .. }) => {
+                f.debug_struct("LabelStatement").field("name", name).finish()
+            }
         }
     }
 }
@@ -819,6 +827,13 @@ impl AstNode {
         }
     }
 
+    pub fn get_label_name(&self) -> Option<&str> {
+        match &self.stmt {
+            AstStatement::LabelStatement(LabelStatement { name, .. }) => Some(name.as_str()),
+            _ => None,
+        }
+    }
+
     pub fn is_empty_statement(&self) -> bool {
         matches!(self.stmt, AstStatement::EmptyStatement(..))
     }
@@ -919,6 +934,12 @@ impl AstNode {
     pub fn is_default_value(&self) -> bool {
         matches!(self.stmt, AstStatement::DefaultValue { .. })
     }
+
+    /// Negates the given element by adding it to a not expression
+    pub fn negate(self: AstNode, mut id_provider: IdProvider) -> AstNode {
+        let location = self.get_location();
+        AstFactory::create_not_expression(self, location, id_provider.next_id())
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -1218,7 +1239,7 @@ impl AstFactory {
     }
 
     /// creates a not-expression
-    pub fn create_not_expression(operator: AstNode, location: SourceLocation, id: AstId) -> AstNode {
+    pub fn create_not_expression(operator: AstNode, location: SourceLocation, id: usize) -> AstNode {
         AstNode {
             stmt: AstStatement::UnaryExpression(UnaryExpression {
                 value: Box::new(operator),
@@ -1465,6 +1486,19 @@ impl AstFactory {
             id_provider,
         )
     }
+
+    pub fn create_jump_statement(
+        condition: Box<AstNode>,
+        target: Box<AstNode>,
+        location: SourceLocation,
+        id: AstId,
+    ) -> AstNode {
+        AstNode { stmt: AstStatement::JumpStatement(JumpStatement { condition, target }), location, id }
+    }
+
+    pub fn create_label_statement(name: String, location: SourceLocation, id: AstId) -> AstNode {
+        AstNode { stmt: AstStatement::LabelStatement(LabelStatement { name }), location, id }
+    }
 }
 #[derive(Clone, PartialEq)]
 pub struct EmptyStatement {}
@@ -1532,3 +1566,18 @@ pub struct CallStatement {
     pub operator: Box<AstNode>,
     pub parameters: Option<Box<AstNode>>,
 }
+
+/// Represents a conditional jump from current location to a specified label
+#[derive(Clone, Debug, PartialEq)]
+pub struct JumpStatement {
+    /// The condition based on which the current statement will perform a jump
+    pub condition: Box<AstNode>,
+    /// The target location (Label) the statement will jump to
+    pub target: Box<AstNode>,
+}
+
+/// Represents a location in code that could be jumbed to
+#[derive(Clone, Debug, PartialEq)]
+pub struct LabelStatement {
+    pub name: String,
+}

compiler/plc_diagnostics/src/diagnostics.rs

@@ -614,6 +614,14 @@ impl Diagnostic {
         Diagnostic::global_name_conflict_with_text(name, location, conflicts, "Duplicate symbol.")
     }
 
+    pub fn duplicate_label(
+        name: &str,
+        location: SourceLocation,
+        conflicts: Vec<SourceLocation>,
+    ) -> Diagnostic {
+        Diagnostic::global_name_conflict_with_text(name, location, conflicts, "Duplicate label.")
+    }
+
     pub fn global_name_conflict_with_text(
         name: &str,
         location: SourceLocation,
@@ -768,6 +776,14 @@ impl Diagnostic {
             err_no: ErrNo::cfc__cyclic_connection,
         }
     }
+
+    pub fn unnamed_control(range: SourceLocation) -> Diagnostic {
+        Diagnostic::SemanticError {
+            message: "Unnamed control".into(),
+            range: vec![range],
+            err_no: ErrNo::cfc__unnamed_control,
+        }
+    }
 }
 
 #[cfg(test)]

compiler/plc_diagnostics/src/errno.rs

@@ -95,6 +95,7 @@ pub enum ErrNo {
     cfc__unconnected_source,
     cfc__cyclic_connection,
     cfc__no_associated_connector,
+    cfc__unnamed_control,
 }
 
 impl Display for ErrNo {

compiler/plc_driver/src/lib.rs

@@ -17,7 +17,11 @@ use std::{
 
 use ast::provider::IdProvider;
 use cli::{CompileParameters, ParameterError};
-use plc::{output::FormatOption, DebugLevel, ErrorFormat, OptimizationLevel, Threads};
+use pipelines::AnnotatedProject;
+use plc::{
+    codegen::CodegenContext, output::FormatOption, DebugLevel, ErrorFormat, OptimizationLevel, Threads,
+};
+
 use plc_diagnostics::{diagnostician::Diagnostician, diagnostics::Diagnostic};
 use project::project::{LibraryInformation, Project};
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
@@ -193,6 +197,38 @@ pub fn compile<T: AsRef<str> + AsRef<OsStr> + Debug>(args: &[T]) -> Result<(), C
     Ok(())
 }
 
+/// Parses and annotates a given project. Can be used in tests or api calls
+pub fn parse_and_annotate<T: SourceContainer>(
+    name: &str,
+    src: Vec<T>,
+) -> Result<AnnotatedProject, Diagnostic> {
+    // Parse the source to ast
+    let project = Project::new(name.to_string()).with_sources(src);
+    let id_provider = IdProvider::default();
+    let mut diagnostician = Diagnostician::default();
+    pipelines::ParsedProject::parse(&project, None, id_provider.clone(), &mut diagnostician)?
+        // Create an index, add builtins
+        .index(id_provider.clone())?
+        // Resolve
+        .annotate(id_provider, &diagnostician)
+}
+
+/// Generates an IR string from a list of sources. Useful for tests or api calls
+pub fn generate_to_string<T: SourceContainer>(name: &str, src: Vec<T>) -> Result<String, Diagnostic> {
+    let mut diagnostician = Diagnostician::default();
+    let project = parse_and_annotate(name, src)?;
+    //Validate
+    project.validate(&mut diagnostician)?;
+    // Generate
+    let context = CodegenContext::create();
+    let module = project.generate_single_module(&context, &CompileOptions::default())?;
+
+    module.map(|it| it.persist_to_string()).ok_or_else(|| Diagnostic::GeneralError {
+        message: "Cannot generate module".to_string(),
+        err_no: plc_diagnostics::errno::ErrNo::general__err,
+    })
+}
+
 fn generate(
     location: Option<PathBuf>,
     compile_parameters: CompileParameters,

compiler/plc_driver/src/pipelines.rs

@@ -187,8 +187,8 @@ impl IndexedProject {
 /// A project that has been annotated with information about different types and used units
 pub struct AnnotatedProject {
     pub units: Vec<(CompilationUnit, IndexSet<Dependency>, StringLiterals)>,
-    index: Index,
-    annotations: AstAnnotations,
+    pub index: Index,
+    pub annotations: AstAnnotations,
 }
 
 impl AnnotatedProject {
@@ -303,7 +303,7 @@ impl AnnotatedProject {
                 )
                 .map(Into::into)?;
 
-            result.push(GeneratedProject { target, objects: vec![obj] });
+            result.push(GeneratedProject { target: target.clone(), objects: vec![obj] });
         }
 
         Ok(result)
@@ -363,7 +363,7 @@ impl AnnotatedProject {
                     })
                     .collect::<Result<Vec<_>, Diagnostic>>()?;
 
-                Ok(GeneratedProject { target, objects })
+                Ok(GeneratedProject { target: target.clone(), objects })
             })
             .collect::<Result<Vec<_>, Diagnostic>>()?;
 
@@ -398,12 +398,12 @@ fn ensure_compile_dirs(targets: &[Target], compile_directory: &Path) -> Result<(
 /// A project that has been transformed into a binary representation
 /// Can be linked to generate a usable application
 #[derive(Debug)]
-pub struct GeneratedProject<'ctx> {
-    target: &'ctx Target,
+pub struct GeneratedProject {
+    target: Target,
     objects: Vec<Object>,
 }
 
-impl GeneratedProject<'_> {
+impl GeneratedProject {
     pub fn link(
         &self,
         objects: &[Object],
@@ -504,7 +504,7 @@ impl GeneratedProject<'_> {
             }
         }?;
 
-        let output: Object = Object::from(output_location).with_target(&self.target.clone());
+        let output: Object = Object::from(output_location).with_target(&self.target);
         Ok(output)
     }
 }

compiler/plc_xml/src/serializer.rs

@@ -221,7 +221,9 @@ declare_type_and_extend_if_needed! {
         (XOutVariable, with_out_variable),
         (XContinuation, with_continuation),
         (XConnector, with_connector),
-        (XReturn, with_return)
+        (XReturn, with_return),
+        (XJump, with_jump),
+        (XLabel, with_label)
     ),
     (
         XVariable, "variable",
@@ -294,6 +296,12 @@ declare_type_and_extend_if_needed! {
         (XConnectionPointIn, with_connection_point_in),
         (XAddData, with_add_data)
     ),
+    (
+        XJump, "jump",
+        (XConnectionPointIn, with_connection_point_in),
+        (XAddData, with_add_data)
+    ),
+    (XLabel, "label",),
     (
         XNegated, "negated",
     ),