Merge remote-tracking branch 'origin/master' into embecosm-online-chane

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -287,20 +287,20 @@ impl PouType {
 
 #[derive(Debug, PartialEq)]
 pub struct ConfigVariable {
-    pub name_segments: Vec<String>,
+    pub reference: AstNode,
     pub data_type: DataTypeDeclaration,
     pub address: AstNode,
     pub location: SourceLocation,
 }
 
 impl ConfigVariable {
     pub fn new(
-        name_segments: Vec<String>,
+        reference: AstNode,
         data_type: DataTypeDeclaration,
         address: AstNode,
         location: SourceLocation,
     ) -> Self {
-        Self { name_segments, data_type, address, location }
+        Self { reference, data_type, address, location }
     }
 }
 
@@ -935,6 +935,14 @@ impl AstNode {
         }
     }
 
+    pub fn get_parent_name_of_reference(&self) -> Option<&str> {
+        if let AstStatement::ReferenceExpr(ReferenceExpr { base: Some(base), .. }, ..) = &self.stmt {
+            base.as_ref().get_flat_reference_name()
+        } else {
+            None
+        }
+    }
+
     pub fn get_label_name(&self) -> Option<&str> {
         match &self.stmt {
             AstStatement::LabelStatement(LabelStatement { name, .. }) => Some(name.as_str()),
@@ -1075,6 +1083,13 @@ impl AstNode {
         let location = self.get_location();
         AstFactory::create_not_expression(self, location, id_provider.next_id())
     }
+
+    pub fn is_template(&self) -> bool {
+        matches!(
+            self.stmt,
+            AstStatement::HardwareAccess(HardwareAccess { access: DirectAccessType::Template, .. })
+        )
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

compiler/plc_ast/src/pre_processor.rs

@@ -187,6 +187,34 @@ fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProv
     update_generated_globals(unit, mangled_globals);
 }
 
+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")
+        };
+
+        if hardware.is_template() {
+            return None;
+        }
+
+        let name = hardware.get_mangled_variable_name();
+        if block.is_some_and(|it| it.variables.iter().any(|v| v.name == name)) {
+            return None;
+        };
+
+        Some(Variable {
+            name,
+            data_type_declaration: data_type.get_inner_pointer_ty().unwrap_or(data_type.clone()),
+            initializer: None,
+            address: None,
+            location: address.get_location(),
+        })
+    });
+
+    update_generated_globals(unit, variables.collect())
+}
+
 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_internal()
@@ -200,32 +228,17 @@ fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Var
             block.variables.push(var);
         }
     }
+
     unit.global_vars.push(block);
 }
 
-fn process_var_config_variables(unit: &mut CompilationUnit) {
-    let variables =
-        unit.var_config.iter().filter_map(|ConfigVariable { data_type, address, location, .. }| {
-            let AstStatement::HardwareAccess(hardware) = &address.stmt else {
-                unreachable!("Must be parsed as hardware access")
-            };
-
-            if hardware.is_template() {
-                return None;
-            }
-
-            let name = hardware.get_mangled_variable_name();
-
-            Some(Variable {
-                name,
-                data_type_declaration: data_type.clone(),
-                initializer: None,
-                address: None,
-                location: location.clone(),
-            })
-        });
-
-    update_generated_globals(unit, variables.collect())
+fn get_internal_global_block(unit: &CompilationUnit) -> Option<&VariableBlock> {
+    unit.global_vars
+        .iter()
+        .position(|block| {
+            block.variable_block_type == VariableBlockType::Global && block.location.is_internal()
+        })
+        .and_then(|index| unit.global_vars.get(index))
 }
 
 fn build_enum_initializer(

compiler/plc_diagnostics/src/diagnostics/diagnostics_registry.rs

@@ -196,12 +196,16 @@ lazy_static! {
         E092,   Info,       include_str!("./error_codes/E092.md"),
         E093,   Warning,    include_str!("./error_codes/E093.md"),
         E094,   Error,      include_str!("./error_codes/E094.md"),
-        E095,   Error,      include_str!("./error_codes/E095.md"), // Action call without `()`
-        E096,   Warning,    include_str!("./error_codes/E096.md"), // Integer Condition
-        E097,   Error,      include_str!("./error_codes/E097.md"), // Invalid Array Range
-        E098,   Error,      include_str!("./error_codes/E098.md"), // Invalid `REF=` assignment
-        E099,   Error,      include_str!("./error_codes/E099.md"), // Invalid `REFERENCE TO` declaration
-        E100,   Error,      include_str!("./error_codes/E100.md"), // Immutable variable address
+        E095,   Error,      include_str!("./error_codes/E095.md"),  // Action call without `()`
+        E096,   Warning,    include_str!("./error_codes/E096.md"),  // Integer Condition
+        E097,   Error,      include_str!("./error_codes/E097.md"),  // Invalid Array Range
+        E098,   Error,      include_str!("./error_codes/E098.md"),  // Invalid `REF=` assignment
+        E099,   Error,      include_str!("./error_codes/E099.md"),  // Invalid `REFERENCE TO` declaration
+        E100,   Error,      include_str!("./error_codes/E100.md"),  // Immutable variable address
+        E101,   Error,      include_str!("./error_codes/E101.md"),  // Invalid VAR_CONFIG / Template Variable Declaration
+        E102,   Error,      include_str!("./error_codes/E102.md"),  // Template variable without hardware binding
+        E103,   Error,      include_str!("./error_codes/E103.md"),  // Immutable Hardware Binding
+        E104,   Error,      include_str!("./error_codes/E104.md"),  // Config Variable With Incomplete Address
     );
 }
 

compiler/plc_diagnostics/src/diagnostics/error_codes/E101.md

@@ -0,0 +1,25 @@
+# Template variable does not exist
+
+A variable was configured in a `VAR_CONFIG` block, but the variable can not be found in the code.
+
+Erroneous code example:
+```
+VAR_CONFIG
+    main.foo.bar AT %IX1.0 : BOOL;
+END_VAR
+
+PROGRAM main
+    VAR
+        foo : foo_fb;
+    END_VAR
+END_PROGRAM
+
+FUNCTION_BLOCK foo_fb
+    VAR
+        qux AT %I* : BOOL;
+    END_VAR
+END_FUNCTION_BLOCK
+```
+
+In this example a variable named `bar` is configured, however the function block `foo_fb` does not contain
+a `bar` variable. The could should have been `main.foo.qux AT %IX1.0 : BOOL` instead for it to be valid.

compiler/plc_diagnostics/src/diagnostics/error_codes/E102.md

@@ -0,0 +1,27 @@
+# Template variable without hardware binding
+
+A template variable must contain a hardware binding.
+
+
+Erroneous code example:
+```
+VAR_CONFIG
+    main.foo.bar AT %IX1.0 : BOOL;
+END_VAR
+
+PROGRAM main
+    VAR
+        foo : foo_fb;
+    END_VAR
+END_PROGRAM
+
+FUNCTION_BLOCK foo_fb
+    VAR
+        bar : BOOL;
+    END_VAR
+END_FUNCTION_BLOCK
+```
+
+In this example the `VAR_CONFIG` block declares the `bar` variable inside `foo_fb` as a
+template variable. However `bar` does not have a hardware binding. For the example to be
+considered valid, `bar` should have been declared as e.g. `bar AT %I* : BOOL`.

compiler/plc_diagnostics/src/diagnostics/error_codes/E103.md

@@ -0,0 +1,27 @@
+# Immutable Hardware Binding
+
+Variables configured in a `VAR_CONFIG` block can not override their hardware binding.
+
+Erroneous code example:
+```
+VAR_CONFIG
+    main.foo.bar AT %IX1.0 : BOOL;
+END_VAR
+
+PROGRAM main
+    VAR
+        foo : foo_fb;
+    END_VAR
+END_PROGRAM
+
+FUNCTION_BLOCK foo_fb
+    VAR
+        bar AT IX1.5: BOOL;
+    END_VAR
+END_FUNCTION_BLOCK
+```
+
+In this example the `VAR_CONFIG` block configures `bar` to have a hardware adress `IX1.0`.
+However, at the same time the `bar` inside the POU `foo_fb` assigns a hardware address `IX1.5`.
+
+For the code to be considered valid, `bar` should have been declared as `bar AT %I* : BOOL`.

compiler/plc_diagnostics/src/diagnostics/error_codes/E104.md

@@ -0,0 +1,13 @@
+# Config Variable With Incomplete Address
+
+Variables defined in a `VAR_CONFIG` block, i.e. config variables, must specify a complete address.
+
+Erroneous code example:
+```
+VAR_CONFIG
+    main.foo.bar AT %I* : BOOL;
+END_VAR
+```
+
+In this example `main.foo.bar` has specified a placeholder hardware address. 
+For the example to be considered valid, a specific address such as `%IX1.0` should have been declared.

src/codegen/generators/statement_generator.rs

@@ -484,7 +484,6 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
 
         let basic_block = builder.get_insert_block().expect(INTERNAL_LLVM_ERROR);
         let exp_gen = self.create_expr_generator();
-        self.register_debug_location(selector);
         let selector_statement = exp_gen.generate_expression(selector)?;
 
         let mut cases = Vec::new();
@@ -530,6 +529,8 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
 
         // now that we collected all cases, go back to the initial block and generate the switch-statement
         builder.position_at_end(basic_block);
+
+        self.register_debug_location(selector);
         builder.build_switch(selector_statement.into_int_value(), else_block, &cases);
 
         builder.position_at_end(continue_block);