wip: init for externals reworked

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -296,6 +296,10 @@ impl Pou {
     pub fn is_generic(&self) -> bool {
         !self.generics.is_empty()
     }
+
+    pub fn is_stateful(&self) -> bool {
+        matches!(self.kind, PouType::Program | PouType::FunctionBlock | PouType::Action | PouType::Class)
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -313,10 +317,15 @@ pub struct Implementation {
     pub access: Option<AccessModifier>,
 }
 
+/// Marks declaration and linking requirements for an ast member
 #[derive(Debug, Copy, PartialEq, Eq, Clone, Hash)]
 pub enum LinkageType {
+    /// The element is declared in the project currently being complied
     Internal,
+    /// The element is declared externally and being used by the project
     External,
+    /// This indicates an element that should not have any declarations within the compiled project
+    /// For example a built in function is implied to exist but not declared
     BuiltIn,
 }
 
@@ -518,8 +527,8 @@ impl VariableBlock {
     }
 
     pub fn with_linkage(mut self, linkage: LinkageType) -> Self {
-       self.linkage = linkage;
-       self
+        self.linkage = linkage;
+        self
     }
 
     pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
@@ -684,6 +693,7 @@ pub struct UserTypeDeclaration {
     pub location: SourceLocation,
     /// stores the original scope for compiler-generated types
     pub scope: Option<String>,
+    pub linkage: LinkageType,
 }
 
 impl Debug for UserTypeDeclaration {

compiler/plc_ast/src/pre_processor.rs

@@ -61,8 +61,13 @@ pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
                     if let DataTypeDeclaration::Definition { mut data_type, location, scope } = *datatype {
                         data_type.set_name(type_name);
                         add_nested_datatypes(name, &mut data_type, &mut new_types, &location);
-                        let data_type =
-                            UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope };
+                        let data_type = UserTypeDeclaration {
+                            data_type: *data_type,
+                            initializer: None,
+                            location,
+                            scope,
+                            linkage: crate::ast::LinkageType::Internal,
+                        };
                         new_types.push(data_type);
                     }
                 }
@@ -289,6 +294,7 @@ fn preprocess_generic_structs(pou: &mut Pou) -> Vec<UserTypeDeclaration> {
             initializer: None,
             scope: Some(pou.name.clone()),
             location: pou.location.clone(),
+            linkage: crate::ast::LinkageType::Internal,
         };
         types.push(data_type);
         generic_types.insert(binding.name.clone(), new_name);
@@ -314,8 +320,13 @@ fn preprocess_return_type(pou: &mut Pou, types: &mut Vec<UserTypeDeclaration>) {
             if let Some(DataTypeDeclaration::Definition { mut data_type, location, scope }) = datatype {
                 data_type.set_name(type_name);
                 add_nested_datatypes(pou.name.as_str(), &mut data_type, types, &location);
-                let data_type =
-                    UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope };
+                let data_type = UserTypeDeclaration {
+                    data_type: *data_type,
+                    initializer: None,
+                    location,
+                    scope,
+                    linkage: crate::ast::LinkageType::Internal,
+                };
                 types.push(data_type);
             }
         }
@@ -350,7 +361,13 @@ fn pre_process_variable_data_type(
         // create index entry
         add_nested_datatypes(new_type_name.as_str(), &mut data_type, types, &location);
         data_type.set_name(new_type_name);
-        types.push(UserTypeDeclaration { data_type: *data_type, initializer: None, location, scope });
+        types.push(UserTypeDeclaration {
+            data_type: *data_type,
+            initializer: None,
+            location,
+            scope,
+            linkage: crate::ast::LinkageType::Internal,
+        });
     }
     //make sure it gets generated
 }
@@ -379,6 +396,7 @@ fn add_nested_datatypes(
             initializer: None,
             location: location.clone(),
             scope,
+            linkage: crate::ast::LinkageType::Internal,
         });
     }
 }

compiler/plc_diagnostics/src/diagnostics.rs

@@ -303,7 +303,8 @@ impl Diagnostic {
 
     pub fn cannot_generate_call_statement(operator: &AstNode) -> Diagnostic {
         //TODO: We could probably get a better slice here
-        Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
+        panic!("{operator:?}");
+        // Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
     }
 
     pub fn cannot_generate_from_empty_literal<T>(type_name: &str, location: T) -> Diagnostic

src/index.rs

@@ -1166,6 +1166,7 @@ impl Default for TypeIndex {
                 information: DataTypeInformation::Void,
                 nature: TypeNature::Any,
                 location: SourceLocation::internal(),
+                linkage: LinkageType::Internal,
             },
         }
     }

src/index/indexer/implementation_indexer.rs

@@ -43,6 +43,7 @@ impl<'i> ImplementationIndexer<'i> {
                 },
                 nature: TypeNature::Derived,
                 location: implementation.name_location.clone(),
+                linkage: implementation.linkage,
             };
 
             self.index.register_pou(PouIndexEntry::create_action_entry(

src/index/indexer/pou_indexer.rs

@@ -60,6 +60,7 @@ impl<'i> PouIndexer<'i> {
             },
             nature: TypeNature::Any,
             location: pou.name_location.clone(),
+            linkage: pou.linkage,
         };
 
         match &pou.kind {
@@ -316,6 +317,7 @@ pub fn register_byref_pointer_type_for(index: &mut Index, inner_type_name: &str,
             },
             nature: TypeNature::Any,
             location: SourceLocation::internal(),
+            linkage: ast::LinkageType::Internal,
         });
     }
 

src/index/indexer/user_type_indexer.rs

@@ -1,8 +1,8 @@
 use plc_ast::{
     ast::{
         flatten_expression_list, get_enum_element_name, Assignment, AstFactory, AstNode, AstStatement,
-        AutoDerefType, DataType, DataTypeDeclaration, RangeStatement, TypeNature, UserTypeDeclaration,
-        Variable,
+        AutoDerefType, DataType, DataTypeDeclaration, LinkageType, RangeStatement, TypeNature,
+        UserTypeDeclaration, Variable,
     },
     literals::AstLiteral,
     visitor::{AstVisitor, Walker},
@@ -58,9 +58,12 @@ impl AstVisitor for UserTypeIndexer<'_, '_> {
 
     fn visit_data_type(&mut self, data_type: &DataType) {
         match &data_type {
-            DataType::StructType { name: Some(name), variables } => {
-                self.index_struct_type(name, variables, StructSource::OriginalDeclaration)
-            }
+            DataType::StructType { name: Some(name), variables } => self.index_struct_type(
+                name,
+                variables,
+                StructSource::OriginalDeclaration,
+                self.user_type.linkage,
+            ),
             DataType::EnumType { name: Some(name), numeric_type, elements } => {
                 self.index_enum_type(name, numeric_type, elements)
             }
@@ -142,6 +145,7 @@ impl UserTypeIndexer<'_, '_> {
                     },
                     nature: TypeNature::__VLA,
                     location: SourceLocation::internal(),
+                    linkage: plc_ast::ast::LinkageType::BuiltIn,
                 });
 
                 // define internal vla members
@@ -225,6 +229,7 @@ impl UserTypeIndexer<'_, '_> {
                 inner_type_name: referenced_type,
                 ndims,
             }),
+            LinkageType::Internal,
         );
     }
 
@@ -267,7 +272,7 @@ impl UserTypeIndexer<'_, '_> {
             dimensions,
         };
 
-        self.register_type(name, information, TypeNature::Any);
+        self.register_type(name, information, TypeNature::Any, LinkageType::Internal);
         let global_init_name = crate::index::get_initializer_name(name);
 
         // TODO unfortunately we cannot share const-expressions between multiple
@@ -321,7 +326,7 @@ impl UserTypeIndexer<'_, '_> {
             referenced_type: numeric_type.to_string(),
         };
 
-        self.register_type(name, information, TypeNature::Int);
+        self.register_type(name, information, TypeNature::Int, LinkageType::Internal);
     }
 
     fn index_sub_range_type(&mut self, name: &str, referenced_type: &str, bounds: Option<&AstNode>) {
@@ -337,16 +342,23 @@ impl UserTypeIndexer<'_, '_> {
             DataTypeInformation::Alias { name: name.into(), referenced_type: referenced_type.into() }
         };
 
-        self.register_type(name, information, TypeNature::Int);
+        self.register_type(name, information, TypeNature::Int, LinkageType::Internal);
     }
 
-    fn register_type(&mut self, name: &str, information: DataTypeInformation, nature: TypeNature) {
+    fn register_type(
+        &mut self,
+        name: &str,
+        information: DataTypeInformation,
+        nature: TypeNature,
+        linkage: LinkageType,
+    ) {
         self.index.register_type(typesystem::DataType {
             name: name.into(),
             initial_value: self.pending_initializer,
             information,
             nature,
             location: self.user_type.location.clone(),
+            linkage,
         });
     }
 
@@ -357,7 +369,7 @@ impl UserTypeIndexer<'_, '_> {
             nature: *nature,
         };
 
-        self.register_type(name, information, TypeNature::Any);
+        self.register_type(name, information, TypeNature::Any, LinkageType::Internal);
     }
 
     fn index_string_type(&mut self, name: &str, is_wide: bool, size: Option<&AstNode>) {
@@ -388,7 +400,7 @@ impl UserTypeIndexer<'_, '_> {
             None => TypeSize::from_literal((DEFAULT_STRING_LEN + 1).into()),
         };
         let information = DataTypeInformation::String { size, encoding };
-        self.register_type(name, information, TypeNature::String);
+        self.register_type(name, information, TypeNature::String, LinkageType::Internal);
 
         //TODO: can we reuse this?
         if let Some(init) = self.pending_initializer {
@@ -434,10 +446,17 @@ impl UserTypeIndexer<'_, '_> {
             information,
             nature: TypeNature::Any,
             location: self.user_type.location.clone(),
+            linkage: plc_ast::ast::LinkageType::Internal,
         });
     }
 
-    fn index_struct_type(&mut self, name: &str, variables: &[Variable], source: StructSource) {
+    fn index_struct_type(
+        &mut self,
+        name: &str,
+        variables: &[Variable],
+        source: StructSource,
+        linkage: LinkageType,
+    ) {
         let scope = Some(name.to_string());
         let members = variables
             .iter()
@@ -480,7 +499,7 @@ impl UserTypeIndexer<'_, '_> {
         let nature = source.get_type_nature();
         let information = DataTypeInformation::Struct { name: name.to_owned(), members, source };
 
-        self.register_type(name, information, nature);
+        self.register_type(name, information, nature, linkage);
 
         //Generate an initializer for the struct
         let global_struct_name = crate::index::get_initializer_name(name);

src/index/tests/index_tests.rs

@@ -862,6 +862,7 @@ fn pre_processing_generates_generic_types() {
         initializer: None,
         location: SourceLocation::internal(),
         scope: Some("myFunc".into()),
+        linkage: LinkageType::Internal,
     };
 
     assert_eq!(format!("{expected:?}"), format!("{:?}", ast.user_types[0]));
@@ -896,6 +897,7 @@ fn pre_processing_generates_nested_generic_types() {
         initializer: None,
         location: SourceLocation::internal(),
         scope: Some("myFunc".into()),
+        linkage: LinkageType::Internal,
     };
 
     assert_eq!(format!("{expected:?}"), format!("{:?}", ast.user_types[0]));

src/lowering.rs

@@ -54,9 +54,10 @@ impl InitVisitor {
         unresolved_initializers: Vec<UnresolvableConstant>,
         id_provider: IdProvider,
     ) -> Self {
+        let unresolved_initializers = dbg!(Initializers::new(&unresolved_initializers, &index));
         Self {
             index,
-            unresolved_initializers: Initializers::new(&unresolved_initializers),
+            unresolved_initializers,
             var_config_initializers: vec![],
             user_inits: FxHashMap::default(),
             ctxt: Context::new(id_provider),
@@ -86,6 +87,7 @@ impl InitVisitor {
         {
             // add the struct to potential `STRUCT_INIT` candidates
             if let Some(name) = user_type.data_type.get_name() {
+                eprintln!("insert user init for {name}");
                 self.user_inits.insert(name.to_string(), false);
             };
         }
@@ -248,11 +250,7 @@ impl InitVisitor {
             |var| {
                 let dti =
                     self.index.get_effective_type_or_void_by_name(var.get_type_name()).get_type_information();
-                let is_external = self
-                    .index
-                    .find_pou(dti.get_name())
-                    .is_some_and(|it| it.get_linkage() == &LinkageType::External);
-                if dti.is_struct() && !is_external {
+                if dti.is_struct() {
                     implicit_calls.push(create_call_statement(
                         &get_init_fn_name(dti.get_name()),
                         var.get_name(),
@@ -324,12 +322,7 @@ impl InitVisitor {
         let info =
             self.index.get_effective_type_or_void_by_name(global.get_type_name()).get_type_information();
 
-        if !info.is_struct()
-            || self
-                .index
-                .find_pou(info.get_name())
-                .is_some_and(|it| it.get_linkage() == &LinkageType::External)
-        {
+        if !info.is_struct() {
             return;
         }
 
@@ -362,7 +355,9 @@ impl AstVisitorMut for InitVisitor {
     }
 
     fn visit_user_type_declaration(&mut self, user_type: &mut plc_ast::ast::UserTypeDeclaration) {
-        self.update_struct_initializers(user_type);
+        if !matches!(user_type.linkage, LinkageType::BuiltIn) {
+            self.update_struct_initializers(user_type);
+        }
         user_type.walk(self);
     }
 
@@ -375,7 +370,7 @@ impl AstVisitorMut for InitVisitor {
     }
 
     fn visit_pou(&mut self, pou: &mut plc_ast::ast::Pou) {
-        if !matches!(pou.linkage, LinkageType::External | LinkageType::BuiltIn) {
+        if !matches!(pou.linkage, LinkageType::BuiltIn) {
             self.unresolved_initializers.maybe_insert_initializer(&pou.name, None, &None);
         }