fix: Add parent class dependency when resolving methods

Author: volsa

src/codegen.rs

@@ -343,7 +343,7 @@ impl<'ink> CodeGen<'ink> {
         let location = (&unit.file).into();
 
         self.debug.finalize();
-        log::debug!("{}", self.module.to_string());
+        log::trace!("{}", self.module.to_string());
 
         #[cfg(feature = "verify")]
         {
@@ -382,7 +382,7 @@ impl<'ink> GeneratedModule<'ink> {
             .create_module_from_ir(buffer)
             .map_err(|it| Diagnostic::new(it.to_string_lossy()).with_error_code("E071"))?;
 
-        log::debug!("{}", module.to_string());
+        log::trace!("{}", module.to_string());
 
         Ok(GeneratedModule { module, location: path.into(), engine: RefCell::new(None) })
     }
@@ -391,7 +391,7 @@ impl<'ink> GeneratedModule<'ink> {
         self.module
             .link_in_module(other.module)
             .map_err(|it| Diagnostic::new(it.to_string_lossy()).with_error_code("E071"))?;
-        log::debug!("Merged: {}", self.module.to_string());
+        log::trace!("Merged: {}", self.module.to_string());
 
         Ok(self)
     }
@@ -570,7 +570,7 @@ impl<'ink> GeneratedModule<'ink> {
     /// * `output`  - The location to save the generated ir file
     pub fn persist_to_ir(&self, output: PathBuf) -> Result<PathBuf, Diagnostic> {
         log::debug!("Output location: {}", output.to_string_lossy());
-        log::debug!("{}", self.persist_to_string());
+        log::trace!("{}", self.persist_to_string());
 
         self.module
             .print_to_file(&output)

src/codegen/generators/data_type_generator.rs

@@ -87,24 +87,28 @@ pub fn generate_data_types<'ink>(
     // and associate them in the llvm index
     for (name, user_type) in &types {
         if let DataTypeInformation::Struct { name: struct_name, .. } = user_type.get_type_information() {
+            log::debug!("creating struct stub `{name}`");
             generator.types_index.associate_type(name, llvm.create_struct_stub(struct_name).into())?;
         }
     }
     // pou_types will always be struct
     for (name, user_type) in &pou_types {
         if let DataTypeInformation::Struct { name: struct_name, .. } = user_type.get_type_information() {
+            log::debug!("creating POU stub `{name}`");
             generator.types_index.associate_pou_type(name, llvm.create_struct_stub(struct_name).into())?;
         }
     }
 
     // now create all other types (enum's, arrays, etc.)
     for (name, user_type) in &types {
+        log::debug!("creating type `{name}`");
         let gen_type = generator.create_type(name, user_type)?;
         generator.types_index.associate_type(name, gen_type)?
         //Get and associate debug type
     }
 
     for (name, user_type) in &pou_types {
+        log::debug!("creating type `{name}`");
         let gen_type = generator.create_type(name, user_type)?;
         generator.types_index.associate_pou_type(name, gen_type)?
     }
@@ -114,8 +118,9 @@ pub fn generate_data_types<'ink>(
     types_to_init.extend(types);
     types_to_init.extend(pou_types);
     // now since all types should be available in the llvm index, we can think about constructing and associating
-    for (_, user_type) in &types_to_init {
+    for (name, user_type) in &types_to_init {
         //Expand all types
+        log::debug!("expanding type `{name}`");
         generator.expand_opaque_types(user_type)?;
     }
 
@@ -206,7 +211,7 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
 
         parameter_types.extend(declared_params);
 
-        let fn_type = match dbg!(return_type) {
+        let fn_type = match return_type {
             AnyTypeEnum::IntType(value) => value.fn_type(parameter_types.as_slice(), false),
             AnyTypeEnum::VoidType(value) => value.fn_type(parameter_types.as_slice(), false),
             _ => unimplemented!(),

src/resolver.rs

@@ -12,7 +12,7 @@ use plc_ast::{
     ast::{
         self, flatten_expression_list, Allocation, Assignment, AstFactory, AstId, AstNode, AstStatement,
         BinaryExpression, CompilationUnit, DataType, DataTypeDeclaration, DirectAccessType, Identifier,
-        Interface, JumpStatement, Operator, Pou, ReferenceAccess, ReferenceExpr, TypeNature,
+        Interface, JumpStatement, Operator, Pou, PouType, ReferenceAccess, ReferenceExpr, TypeNature,
         UserTypeDeclaration, Variable,
     },
     control_statements::{AstControlStatement, ReturnStatement},
@@ -1547,15 +1547,22 @@ impl<'i> TypeAnnotator<'i> {
         };
         if resolved_names.insert(Dependency::Datatype(datatype.get_name().to_string())) {
             match datatype.get_type_information() {
-                DataTypeInformation::Struct { members, .. } => {
+                DataTypeInformation::Struct { members, source, .. } => {
                     for member in members {
                         resolved_names =
                             self.get_datatype_dependencies(member.get_type_name(), resolved_names);
                     }
+
+                    if let StructSource::Pou(PouType::Method { parent, .. }) = source {
+                        resolved_names = self.get_datatype_dependencies(parent, resolved_names);
+                    }
+
                     resolved_names
                 }
                 DataTypeInformation::Array { inner_type_name, .. }
                 | DataTypeInformation::Pointer { inner_type_name, .. } => {
+                    resolved_names
+                        .insert(Dependency::Datatype(datatype.get_type_information().get_name().to_string()));
                     self.get_datatype_dependencies(inner_type_name, resolved_names)
                 }
                 _ => {