feat: Polymorphism (Classes and Function Blocks)

compiler/plc_ast/src/ast.rs

@@ -16,6 +16,7 @@ use crate::{
     literals::{AstLiteral, StringValue},
     pre_processor,
     provider::IdProvider,
+    ser::AstSerializer,
 };
 
 use plc_source::source_location::*;
@@ -395,6 +396,14 @@ impl PouType {
     pub fn is_stateful(&self) -> bool {
         matches!(self, PouType::FunctionBlock | PouType::Program | PouType::Class)
     }
+
+    pub fn is_class(&self) -> bool {
+        matches!(self, PouType::Class)
+    }
+
+    pub fn is_function_block(&self) -> bool {
+        matches!(self, PouType::FunctionBlock)
+    }
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -504,6 +513,10 @@ pub struct VariableBlock {
 }
 
 impl VariableBlock {
+    pub fn global() -> Self {
+        VariableBlock::default().with_block_type(VariableBlockType::Global)
+    }
+
     pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
         self.kind = block_type;
         self
@@ -1306,6 +1319,10 @@ impl AstNode {
         matches!(node.get_stmt_peeled(), AstStatement::Super(Some(_)))
     }
 
+    pub fn is_super_or_super_deref(&self) -> bool {
+        self.is_super() || self.is_super_deref()
+    }
+
     pub fn has_super_metadata(&self) -> bool {
         self.get_metadata()
             .or_else(|| self.get_identifier().and_then(|it| it.get_metadata()))
@@ -1412,6 +1429,30 @@ impl AstNode {
         AstNode { metadata: Some(metadata), ..self }
     }
 
+    pub fn is_deref(&self) -> bool {
+        matches!(
+            self,
+            AstNode {
+                stmt: AstStatement::ReferenceExpr(ReferenceExpr { access: ReferenceAccess::Deref, .. }),
+                ..
+            }
+        )
+    }
+
+    pub fn get_call_operator(&self) -> Option<&AstNode> {
+        match &self.stmt {
+            AstStatement::CallStatement(CallStatement { operator, .. }) => Some(operator),
+            _ => None,
+        }
+    }
+
+    pub fn get_ref_expr_mut(&mut self) -> Option<&mut ReferenceExpr> {
+        match &mut self.stmt {
+            AstStatement::ReferenceExpr(expr) => Some(expr),
+            _ => None,
+        }
+    }
+
     pub fn get_deref_expr(&self) -> Option<&ReferenceExpr> {
         match &self.stmt {
             AstStatement::ReferenceExpr(expr) => match expr {
@@ -1421,6 +1462,24 @@ impl AstNode {
             _ => None,
         }
     }
+
+    pub fn get_base(&self) -> Option<&AstNode> {
+        match &self.stmt {
+            AstStatement::ReferenceExpr(ReferenceExpr { base: Some(base), .. }) => Some(base.as_ref()),
+            _ => None,
+        }
+    }
+
+    pub fn get_base_mut(&mut self) -> Option<&mut AstNode> {
+        match &mut self.stmt {
+            AstStatement::ReferenceExpr(ReferenceExpr { base: Some(base), .. }) => Some(base.as_mut()),
+            _ => None,
+        }
+    }
+
+    pub fn as_string(&self) -> String {
+        AstSerializer::format(self)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -1451,9 +1510,17 @@ impl Display for Operator {
             Operator::Multiplication => "*",
             Operator::Division => "/",
             Operator::Equal => "=",
+            Operator::NotEqual => "<>",
             Operator::Modulo => "MOD",
+            Operator::Less => "<",
+            Operator::Greater => ">",
+            Operator::LessOrEqual => "<=",
+            Operator::GreaterOrEqual => ">=",
+            Operator::Not => "NOT",
+            Operator::And => "AND",
+            Operator::Or => "OR",
+            Operator::Xor => "XOR",
             Operator::Exponentiation => "**",
-            _ => unimplemented!(),
         };
         f.write_str(symbol)
     }

compiler/plc_ast/src/lib.rs

@@ -8,4 +8,5 @@ pub mod literals;
 pub mod mut_visitor;
 mod pre_processor;
 pub mod provider;
+pub mod ser;
 pub mod visitor;

compiler/plc_ast/src/pre_processor.rs

@@ -196,7 +196,6 @@ fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProv
 }
 
 fn process_var_config_variables(unit: &mut CompilationUnit) {
-    let block = get_internal_global_block(unit);
     let variables = unit.var_config.iter().filter_map(|ConfigVariable { data_type, address, .. }| {
         let AstStatement::HardwareAccess(hardware) = &address.stmt else {
             unreachable!("Must be parsed as hardware access")
@@ -206,10 +205,12 @@ fn process_var_config_variables(unit: &mut CompilationUnit) {
             return None;
         }
 
+        // Check if the mangled variable already exists in any of the global variable blocks
+        // XXX: Not a fan of this, we should fix the underlying issue with variable block creation here...
         let name = hardware.get_mangled_variable_name();
-        if block.is_some_and(|it| it.variables.iter().any(|v| v.name == name)) {
-            return None;
-        };
+        if find_mangled_variable(unit, &name) {
+            return None; // Already exists, skip
+        }
 
         Some(Variable {
             name,
@@ -220,7 +221,7 @@ fn process_var_config_variables(unit: &mut CompilationUnit) {
         })
     });
 
-    update_generated_globals(unit, variables.collect())
+    update_generated_globals(unit, variables.collect());
 }
 
 fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
@@ -242,11 +243,8 @@ fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Var
     unit.global_vars.push(block);
 }
 
-fn get_internal_global_block(unit: &CompilationUnit) -> Option<&VariableBlock> {
-    unit.global_vars
-        .iter()
-        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
-        .and_then(|index| unit.global_vars.get(index))
+fn find_mangled_variable(unit: &CompilationUnit, name: &str) -> bool {
+    unit.global_vars.iter().flat_map(|block| &block.variables).any(|var| var.name == name)
 }
 
 fn build_enum_initializer(