wip: add adrs, experimental skip externals not yet working as expected

ghaith · ghaith · commit c8245a6848ab · 2025-11-07T16:17:54.000+01:00
diff --git a/compiler/plc_ast/src/ast.rs b/compiler/plc_ast/src/ast.rs
@@ -517,6 +517,11 @@ impl VariableBlock {
         VariableBlock::default().with_block_type(VariableBlockType::Global)
     }
 
+    pub fn with_linkage(mut self, linkage: LinkageType) -> Self {
+       self.linkage = linkage;
+       self
+    }
+
     pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
         self.kind = block_type;
         self
diff --git a/src/lowering/initializers.rs b/src/lowering/initializers.rs
@@ -127,15 +127,15 @@ impl InitVisitor {
 
 fn create_var_config_init(statements: Vec<AstNode>, mut id_provider: IdProvider) -> CompilationUnit {
     let loc = SourceLocation::internal_in_unit(Some(INIT_COMPILATION_UNIT));
-    let pou = new_pou(VAR_CONFIG_INIT, id_provider.next_id(), vec![], PouType::Init, &loc); // this can probably just be internal
-    let implementation = new_implementation(VAR_CONFIG_INIT, statements, PouType::Init, loc);
+    let pou = new_pou(VAR_CONFIG_INIT, id_provider.next_id(), vec![], PouType::Init, LinkageType::Internal, &loc); // this can probably just be internal
+    let implementation = new_implementation(VAR_CONFIG_INIT, statements, PouType::Init, LinkageType::Internal, loc);
     new_unit(pou, implementation, INIT_COMPILATION_UNIT)
 }
 
 fn create_init_units(lowerer: &InitVisitor) -> Vec<CompilationUnit> {
     let lookup = lowerer.unresolved_initializers.keys().map(|it| it.as_str()).collect::<FxIndexSet<_>>();
     lowerer
-        .unresolved_initializers
+            .unresolved_initializers
         .iter()
         .filter_map(|(container, init)| {
             // globals will be initialized in the `__init` body
@@ -158,11 +158,11 @@ fn create_init_unit(
     let mut id_provider = lowerer.ctxt.id_provider.clone();
     let init_fn_name = get_init_fn_name(container_name);
     log::trace!("creating {init_fn_name}");
-    let (is_stateless, location) = lowerer
+    let (is_stateless, location, linkage) = lowerer
         .index
         .find_pou(container_name)
-        .map(|it| (it.is_function() || it.is_method(), it.get_location()))
-        .unwrap_or_else(|| (false, &lowerer.index.get_type_or_panic(container_name).location));
+        .map(|it| (it.is_function() || it.is_method(), it.get_location(), *it.get_linkage()))
+        .unwrap_or_else(|| (false, &lowerer.index.get_type_or_panic(container_name).location, LinkageType::Internal));
 
     if is_stateless {
         // functions do not get their own init-functions -
@@ -188,7 +188,7 @@ fn create_init_unit(
         "self".to_string(),
     );
 
-    let init_pou = new_pou(&init_fn_name, id_provider.next_id(), self_param, PouType::Init, &location);
+    let init_pou = new_pou(&init_fn_name, id_provider.next_id(), self_param, PouType::Init, linkage, &location);
 
     let mut statements = Vec::new();
 
@@ -236,7 +236,7 @@ fn create_init_unit(
         .collect::<Vec<_>>();
 
     let statements = [member_init_calls, statements].concat();
-    let implementation = new_implementation(&init_fn_name, statements, PouType::Init, location);
+    let implementation = new_implementation(&init_fn_name, statements, PouType::Init, linkage, location);
 
     Some(new_unit(init_pou, implementation, INIT_COMPILATION_UNIT))
 }
@@ -261,8 +261,10 @@ fn create_user_init_units(lowerer: &InitVisitor) -> Vec<CompilationUnit> {
                     location: location.clone(),
                 }])];
 
+
+            let linkage = lowerer.index.find_pou(container_name).map(|it|*it.get_linkage()).unwrap_or(LinkageType::Internal);
             let fn_name = get_user_init_fn_name(container_name);
-            let init_pou = new_pou(&fn_name, id_provider.next_id(), param, PouType::Init, &location);
+            let init_pou = new_pou(&fn_name, id_provider.next_id(), param, PouType::Init, linkage, &location);
 
             let mut statements = lowerer
                 .index
@@ -297,7 +299,7 @@ fn create_user_init_units(lowerer: &InitVisitor) -> Vec<CompilationUnit> {
                     AstFactory::create_call_statement(op, None, id_provider.next_id(), location.clone());
                 statements.push(call_statement);
             }
-            let implementation = new_implementation(&fn_name, statements, PouType::Init, location);
+            let implementation = new_implementation(&fn_name, statements, PouType::Init, linkage, location);
 
             new_unit(init_pou, implementation, INIT_COMPILATION_UNIT)
         })
@@ -319,6 +321,7 @@ fn create_init_wrapper_function(
         id_provider.next_id(),
         vec![],
         PouType::ProjectInit,
+        LinkageType::Internal,
         &SourceLocation::internal(),
     );
 
@@ -387,7 +390,7 @@ fn create_init_wrapper_function(
     let user_init_calls = get_global_user_init_statements(lowerer);
     let statements = [calls, statements, user_init_calls].concat();
     let implementation =
-        new_implementation(init_symbol_name, statements, PouType::ProjectInit, SourceLocation::internal());
+        new_implementation(init_symbol_name, statements, PouType::ProjectInit, LinkageType::Internal, SourceLocation::internal());
     let mut global_init = new_unit(init_pou, implementation, init_symbol_name);
 
     if skip_var_config {
@@ -449,6 +452,7 @@ fn new_pou(
     id: AstId,
     variable_blocks: Vec<VariableBlock>,
     kind: PouType,
+    linkage: LinkageType,
     location: &SourceLocation,
 ) -> Pou {
     Pou {
@@ -473,6 +477,7 @@ fn new_implementation(
     name: &str,
     statements: Vec<AstNode>,
     pou_type: PouType,
+    linkage: LinkageType,
     location: SourceLocation,
 ) -> Implementation {
     Implementation {
@@ -555,8 +560,13 @@ fn create_vtable_initializer(lowerer: &InitVisitor, ids: &mut IdProvider, pou_na
 
 #[cfg(test)]
 mod tests {
+    use inkwell::module::Linkage;
+    use insta::assert_debug_snapshot;
+    use plc_ast::ast::LinkageType;
     use test_utils::parse_and_validate_buffered_ast;
 
+    use crate::lowering::vtable;
+
     #[test]
     fn usertype_todo_better_name_00() {
         let src = r#"
@@ -1638,4 +1648,90 @@ mod tests {
         ]
         "#);
     }
+
+    #[test]
+    fn function_block_initializer_with_base_call() {
+        let src = r#"
+        FUNCTION_BLOCK FB_Base
+            VAR
+                baseValue: DINT := 5;
+            END_VAR
+        END_FUNCTION_BLOCK
+
+        FUNCTION_BLOCK FB_Derived EXTENDS FB_Base
+            VAR
+                derivedValue: DINT := 10;
+            END_VAR
+        END_FUNCTION_BLOCK
+        "#;
+
+        let units = parse_and_validate_buffered_ast(src);
+        // Check that a base initializer call is generated
+        let init_unit = &units
+            .iter()
+            .find(|unit| unit.file.get_name().is_some_and(|name| name == "__initializers"))
+            .unwrap();
+        let init_base = init_unit.implementations.iter().find(|it| it.name == "__init_fb_base").unwrap();
+        assert_eq!(init_base.linkage, LinkageType::Internal);
+        // Check that a vtable_init for base was generated
+        let vtable_init_base = init_unit.implementations.iter().find(|it| it.name == "__init___vtable_fb_base").unwrap();
+        assert_eq!(vtable_init_base.linkage, LinkageType::Internal);
+        // Make sure the variable block containing the base vtable is internal
+        let variable_block = units[0].global_vars.iter().find(|it| it.variables.iter().any(|it| it.name == "__vtable_FB_Base_instance")).unwrap();
+        assert_eq!(variable_block.linkage, LinkageType::Internal);
+        // Make sure the derived initializer is still internal
+        let init_derived = init_unit.implementations.iter().find(|it| it.name == "__init_fb_derived").unwrap();
+        assert_eq!(init_derived.linkage, LinkageType::Internal);
+        // Make sure the derived vtable initializer is still internal
+        let vtable_init_derived = init_unit.implementations.iter().find(|it| it.name == "__init___vtable_fb_derived").unwrap();
+        assert_eq!(vtable_init_derived.linkage, LinkageType::Internal);
+        // Make sure the variable block containing the derived vtable is internal
+        let variable_block = units[0].global_vars.iter().find(|it| it.variables.iter().any(|it| it.name == "__vtable_FB_Derived_instance")).unwrap();
+        assert_eq!(variable_block.linkage, LinkageType::Internal);
+    }
+
+
+    #[test]
+    fn function_block_initializer_with_external_base_call() {
+        let src = r#"
+        {external}
+        FUNCTION_BLOCK FB_Base
+            VAR
+                baseValue: DINT := 5;
+            END_VAR
+        END_FUNCTION_BLOCK
+
+        FUNCTION_BLOCK FB_Derived EXTENDS FB_Base
+            VAR
+                derivedValue: DINT := 10;
+            END_VAR
+        END_FUNCTION_BLOCK
+        "#;
+
+        let units = parse_and_validate_buffered_ast(src);
+        // Check that a base initializer call is generated
+        let init_unit = &units
+            .iter()
+            .find(|unit| unit.file.get_name().is_some_and(|name| name == "__initializers"))
+            .unwrap();
+        let init_base = init_unit.implementations.iter().find(|it| it.name == "__init_fb_base").unwrap();
+        assert_eq!(init_base.linkage, LinkageType::External);
+        // Check that a vtable_init for base was generated
+        let vtable_init_base = init_unit.implementations.iter().find(|it| it.name == "__init___vtable_fb_base").unwrap();
+        assert_eq!(vtable_init_base.linkage, LinkageType::External);
+        // Make sure the variable block containing the base vtable is internal
+        let variable_block = units[0].global_vars.iter().find(|it| it.variables.iter().any(|it| it.name == "__vtable_FB_Base_instance")).unwrap();
+        assert_eq!(variable_block.linkage, LinkageType::External);
+        // Make sure the derived initializer is still internal
+        let init_derived = init_unit.implementations.iter().find(|it| it.name == "__init_fb_derived").unwrap();
+        assert_eq!(init_derived.linkage, LinkageType::Internal);
+        // Make sure the derived vtable initializer is still internal
+        let vtable_init_derived = init_unit.implementations.iter().find(|it| it.name == "__init___vtable_fb_derived").unwrap();
+        assert_eq!(vtable_init_derived.linkage, LinkageType::Internal);
+        // Make sure the variable block containing the derived vtable is internal
+        let variable_block = units[0].global_vars.iter().find(|it| it.variables.iter().any(|it| it.name == "__vtable_FB_Derived_instance")).unwrap();
+        assert_eq!(variable_block.linkage, LinkageType::Internal);
+    }
+
+
 }
diff --git a/src/lowering/vtable.rs b/src/lowering/vtable.rs
@@ -89,19 +89,31 @@ impl VirtualTableGenerator {
     pub fn generate(&mut self, index: &Index, units: &mut Vec<CompilationUnit>) {
         for unit in units {
             let mut definitions = Vec::new();
-            let mut instances = Vec::new();
+            let mut internal_instances = Vec::new();
+            let mut external_instances = Vec::new();
 
             for pou in unit.pous.iter_mut().filter(|pou| pou.kind.is_class() | pou.kind.is_function_block()) {
                 self.patch_vtable_member(pou);
                 let definition = self.generate_vtable_definition(index, pou);
                 let instance = self.generate_vtable_instance(pou, &definition);
 
                 definitions.push(definition);
-                instances.push(instance);
+                if pou.linkage == LinkageType::External {
+                    external_instances.push(instance);
+                } else {
+                    internal_instances.push(instance);
+                }
             }
 
             unit.user_types.extend(definitions);
-            unit.global_vars.push(VariableBlock::global().with_variables(instances));
+            unit.global_vars.push(VariableBlock::global().with_variables(internal_instances));
+            if !external_instances.is_empty() {
+                unit.global_vars.push(
+                    VariableBlock::global()
+                        .with_linkage(LinkageType::External)
+                        .with_variables(external_instances),
+                );
+            }
         }
     }
 
diff --git a/src/resolver/const_evaluator.rs b/src/resolver/const_evaluator.rs
@@ -140,8 +140,9 @@ pub fn evaluate_constants(mut index: Index) -> (Index, Vec<UnresolvableConstant>
                     // there was an error during evaluation
                     (Err(kind), _) => {
                         //error during resolving
+                        dbg!(index.get_mut_const_expressions().find_const_expression(&candidate));
                         unresolvable.push(
-                            UnresolvableConstant::new(candidate, kind.get_reason()).with_kind(kind.clone()),
+                            dbg!(UnresolvableConstant::new(candidate, kind.get_reason()).with_kind(kind.clone())),
                         );
                         index
                             .get_mut_const_expressions()
diff --git a/src/tests/adr/initializer_functions_adr.rs b/src/tests/adr/initializer_functions_adr.rs
