Merge branch 'master' into abroooo/fix_dbg_alignment

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -2,6 +2,7 @@
 
 use std::{
     fmt::{Debug, Display, Formatter},
+    hash::Hash,
     ops::Range,
 };
 
@@ -54,10 +55,11 @@ pub struct Pou {
 #[derive(Debug, PartialEq)]
 pub struct Interface {
     pub id: AstId,
-    pub identifier: Identifier,
-    pub methods: Vec<Pou>,
+    pub ident: Identifier,
     pub location: SourceLocation,
+    pub methods: Vec<Pou>,
     pub extensions: Vec<Identifier>,
+    pub properties: Vec<PropertyBlock>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
@@ -69,12 +71,21 @@ pub struct Identifier {
 /// The property container as a whole, which contains [`PropertyImplementation`]s
 #[derive(Debug, PartialEq, Clone)]
 pub struct PropertyBlock {
-    pub name: Identifier,
-    pub return_type: DataTypeDeclaration,
+    pub ident: Identifier,
+    pub datatype: DataTypeDeclaration,
     pub implementations: Vec<PropertyImplementation>,
 }
 
-/// The declaration and implementation of a properties accessor (GET or SET)
+impl Eq for PropertyBlock {}
+
+impl Hash for PropertyBlock {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ident.hash(state);
+        self.datatype.get_name().hash(state);
+        self.datatype.get_location().hash(state);
+    }
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub struct PropertyImplementation {
     pub kind: PropertyKind,
@@ -84,24 +95,12 @@ pub struct PropertyImplementation {
     pub end_location: SourceLocation,
 }
 
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum PropertyKind {
     Get,
     Set,
 }
 
-impl From<&PropertyBlock> for Variable {
-    fn from(value: &PropertyBlock) -> Self {
-        Variable {
-            name: value.name.name.clone(),
-            data_type_declaration: value.return_type.clone(),
-            initializer: None,
-            address: None,
-            location: value.name.location.clone(),
-        }
-    }
-}
-
 impl std::fmt::Display for PropertyKind {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -353,6 +352,9 @@ pub enum PouType {
         /// The parent of this method, i.e. a function block, class or an interface
         parent: String,
 
+        /// The property name (pre-mangled) and its type, if the method originated from a property
+        property: Option<(String, PropertyKind)>,
+
         declaration_kind: DeclarationKind,
     },
     Init,
@@ -494,14 +496,14 @@ pub struct VariableBlock {
     pub constant: bool,
     pub retain: bool,
     pub variables: Vec<Variable>,
-    pub variable_block_type: VariableBlockType,
+    pub kind: VariableBlockType,
     pub linkage: LinkageType,
     pub location: SourceLocation,
 }
 
 impl VariableBlock {
     pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
-        self.variable_block_type = block_type;
+        self.kind = block_type;
         self
     }
 
@@ -518,7 +520,7 @@ impl Default for VariableBlock {
             constant: false,
             retain: false,
             variables: vec![],
-            variable_block_type: VariableBlockType::Local,
+            kind: VariableBlockType::Local,
             linkage: LinkageType::Internal,
             location: SourceLocation::internal(),
         }
@@ -529,7 +531,7 @@ impl Debug for VariableBlock {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("VariableBlock")
             .field("variables", &self.variables)
-            .field("variable_block_type", &self.variable_block_type)
+            .field("variable_block_type", &self.kind)
             .finish()
     }
 }
@@ -1379,8 +1381,12 @@ mod tests {
         assert_eq!(PouType::Action.to_string(), "Action");
         assert_eq!(PouType::Class.to_string(), "Class");
         assert_eq!(
-            PouType::Method { parent: String::new(), declaration_kind: DeclarationKind::Concrete }
-                .to_string(),
+            PouType::Method {
+                parent: String::new(),
+                property: None,
+                declaration_kind: DeclarationKind::Concrete
+            }
+            .to_string(),
             "Method"
         );
     }

compiler/plc_ast/src/pre_processor.rs

@@ -224,9 +224,11 @@ fn process_var_config_variables(unit: &mut CompilationUnit) {
 }
 
 fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
-    let mut block = if let Some(index) = unit.global_vars.iter().position(|block| {
-        block.variable_block_type == VariableBlockType::Global && block.location.is_builtin_internal()
-    }) {
+    let mut block = if let Some(index) = unit
+        .global_vars
+        .iter()
+        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
+    {
         unit.global_vars.remove(index)
     } else {
         VariableBlock::default().with_block_type(VariableBlockType::Global)
@@ -243,9 +245,7 @@ fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Var
 fn get_internal_global_block(unit: &CompilationUnit) -> Option<&VariableBlock> {
     unit.global_vars
         .iter()
-        .position(|block| {
-            block.variable_block_type == VariableBlockType::Global && block.location.is_builtin_internal()
-        })
+        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
         .and_then(|index| unit.global_vars.get(index))
 }
 

compiler/plc_driver/src/pipelines.rs

@@ -26,7 +26,6 @@ use plc::{
     linker::LinkerType,
     lowering::{
         property::PropertyLowerer,
-        validator::ParticipantValidator,
         {calls::AggregateTypeLowerer, InitVisitor},
     },
     output::FormatOption,
@@ -57,7 +56,6 @@ use toml;
 
 pub mod participant;
 pub mod property;
-pub mod validator;
 
 pub struct BuildPipeline<T: SourceContainer> {
     pub context: GlobalContext,
@@ -258,22 +256,15 @@ impl<T: SourceContainer> BuildPipeline<T> {
     /// Register all default participants (excluding codegen/linking)
     pub fn register_default_participants(&mut self) {
         use participant::InitParticipant;
-        // XXX: should we use a static array of participants?
-        let participants: Vec<Box<dyn PipelineParticipant>> = vec![Box::new(ParticipantValidator::new(
-            &self.context,
-            self.compile_parameters.as_ref().map(|it| it.error_format).unwrap_or_default(),
-        ))];
 
+        // XXX: should we use a static array of participants?
         let mut_participants: Vec<Box<dyn PipelineParticipantMut>> = vec![
             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())),
         ];
 
-        for participant in participants {
-            self.register_participant(participant)
-        }
         for participant in mut_participants {
             self.register_mut_participant(participant)
         }

compiler/plc_driver/src/pipelines/property.rs

@@ -11,7 +11,7 @@ impl PipelineParticipantMut for PropertyLowerer {
         let ParsedProject { mut units } = parsed_project;
 
         for unit in &mut units {
-            self.lower_properties_to_pous(unit);
+            self.properties_to_pous(unit);
         }
 
         ParsedProject { units }
@@ -22,7 +22,7 @@ impl PipelineParticipantMut for PropertyLowerer {
         self.annotations = Some(annotations);
 
         for AnnotatedUnit { unit, .. } in &mut units.iter_mut() {
-            self.lower_references_to_calls(unit);
+            self.properties_to_fncalls(unit);
         }
 
         let project = IndexedProject {

compiler/plc_driver/src/pipelines/validator.rs

@@ -192,7 +192,7 @@ impl AstVisitorMut for InheritanceLowerer {
 
         let block = VariableBlock {
             variables: vec![base_var],
-            variable_block_type: VariableBlockType::Local,
+            kind: VariableBlockType::Local,
             linkage: LinkageType::Internal,
             location: SourceLocation::internal(),
             ..Default::default()
@@ -2141,6 +2141,7 @@ mod units_tests {
             ],
             pou_type: Method {
                 parent: "child",
+                property: None,
                 declaration_kind: Concrete,
             },
             return_type: None,
@@ -2168,13 +2169,14 @@ mod units_tests {
 
         let (_, project) = parse_and_annotate("test", vec![src]).unwrap();
         let unit = &project.units[0].get_unit().implementations[1];
-        assert_debug_snapshot!(unit, @r#"
+        assert_debug_snapshot!(unit, @r###"
         Implementation {
             name: "bar.set0",
             type_name: "bar.set0",
             linkage: Internal,
             pou_type: Method {
                 parent: "bar",
+                property: None,
                 declaration_kind: Concrete,
             },
             statements: [
@@ -2255,7 +2257,7 @@ mod units_tests {
                 Protected,
             ),
         }
-        "#);
+        "###);
     }
 }
 
@@ -2387,7 +2389,7 @@ mod inherited_properties {
 
         let (_, AnnotatedProject { units, .. }) = parse_and_annotate("test", vec![src]).unwrap();
         let implementation = &units[0].get_unit().implementations[1];
-        let stmt = &dbg!(implementation).statements[0];
+        let stmt = &implementation.statements[0];
         assert_debug_snapshot!(stmt, @r###"
         CallStatement {
             operator: ReferenceExpr {
@@ -2433,7 +2435,7 @@ mod inherited_properties {
 
         let (_, AnnotatedProject { units, .. }) = parse_and_annotate("test", vec![src]).unwrap();
         let implementation = &units[0].get_unit().implementations[2];
-        let stmt = &dbg!(implementation).statements[0];
+        let stmt = &implementation.statements[0];
         assert_debug_snapshot!(stmt, @r###"
         CallStatement {
             operator: ReferenceExpr {
@@ -2491,7 +2493,7 @@ mod inherited_properties {
         .into();
 
         let (_, AnnotatedProject { units, .. }) = parse_and_annotate("test", vec![src]).unwrap();
-        let implementation = dbg!(&units[0].get_unit().implementations[2]);
+        let implementation = &units[0].get_unit().implementations[2];
         let stmt = &implementation.statements[0];
         assert_debug_snapshot!(stmt, @r###"
         CallStatement {

compiler/plc_lowering/src/inheritance.rs

@@ -534,3 +534,54 @@ fn complex_array_access_generated() {
     }
     "###);
 }
+
+#[test]
+fn properties_are_methods() {
+    let property = codegen(
+        "
+        FUNCTION_BLOCK fb
+            VAR
+                localPrivateVariable : DINT;
+            END_VAR
+            PROPERTY foo : DINT
+                GET
+                    foo := localPrivateVariable;
+                END_GET
+
+                SET
+                    localPrivateVariable := foo;
+                END_SET
+            END_PROPERTY
+        END_FUNCTION_BLOCK
+        ",
+    );
+
+    let method = codegen(
+        "
+        FUNCTION_BLOCK fb
+          VAR
+            localPrivateVariable : DINT;
+          END_VAR
+
+          METHOD __get_foo : DINT
+            VAR
+              foo : DINT;
+            END_VAR
+
+            foo := localPrivateVariable;
+            __get_foo := foo;
+          END_METHOD
+
+          METHOD __set_foo
+            VAR_INPUT
+              foo : DINT;
+            END_VAR
+
+            localPrivateVariable := foo;
+          END_METHOD
+        END_FUNCTION_BLOCK
+        ",
+    );
+
+    assert_eq!(property, method);
+}