Temporary fix for not yet indexed types in codgen

Author: volsa

src/codegen/generators/data_type_generator.rs

@@ -97,22 +97,43 @@ pub fn generate_data_types<'ink>(
         }
     }
 
-    // now create all other types (enum's, arrays, etc.)
+    // Separate function types from other types to process them later
+    let mut function_types = vec![];
+    let mut non_function_types = vec![];
+    
     for (name, user_type) in &types {
+        if let DataTypeInformation::Struct { source: StructSource::Pou(PouType::Function | PouType::Method { .. }, ..), .. } = user_type.get_type_information() {
+            function_types.push((*name, *user_type));
+        } else {
+            non_function_types.push((*name, *user_type));
+        }
+    }
+
+    // First create all POU types (excluding functions/methods) - this includes function blocks like ClassA, ClassB
+    for (name, user_type) in &pou_types {
+        let gen_type = generator.create_type(name, user_type)?;
+        generator.types_index.associate_pou_type(name, gen_type)?
+    }
+
+    // Then create function types now that all POU types are available
+    for (name, user_type) in &function_types {
         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 {
+    // Finally create all non-function types (enum's, arrays, VTable structs, etc.)
+    for (name, user_type) in &non_function_types {
         let gen_type = generator.create_type(name, user_type)?;
-        generator.types_index.associate_pou_type(name, gen_type)?
+        generator.types_index.associate_type(name, gen_type)?
+        //Get and associate debug type
     }
 
-    // Combine the types and pou_types into a single Vector
+    // Combine all types in the order they were processed
     let mut types_to_init = VecDeque::new();
-    types_to_init.extend(types);
     types_to_init.extend(pou_types);
+    types_to_init.extend(function_types);
+    types_to_init.extend(non_function_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 {
         //Expand all types
@@ -176,7 +197,7 @@ pub fn generate_data_types<'ink>(
 }
 
 impl<'ink> DataTypeGenerator<'ink, '_> {
-    fn create_function_type(&self, name: &str) -> Result<FunctionType<'ink>, Diagnostic> {
+    fn create_function_type(&mut self, name: &str) -> Result<FunctionType<'ink>, Diagnostic> {
         let return_type_dt = self.index.find_return_type(name).unwrap_or(self.index.get_void_type());
 
         let return_type = self
@@ -190,8 +211,20 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
         // For methods, we need to add the 'this' parameter as the first parameter
         if let Some(PouIndexEntry::Method { parent_name, .. }) = self.index.find_pou(name) {
             // Get the owner class type and add it as the first parameter (this pointer)
-            if let Ok(owner_type) = self.types_index.get_associated_type(parent_name) {
+            // If the parent type is not available yet (e.g., during early type creation), 
+            // we'll create a properly named opaque struct as placeholder
+            if let Ok(owner_type) = self.types_index.get_associated_pou_type(parent_name) {
                 parameter_types.push(owner_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into());
+            } else {
+                // Create an opaque struct type with the exact same name that will be used
+                // when the full type is created. This ensures LLVM will treat them as the same type.
+                let opaque_struct = self.llvm.context.opaque_struct_type(parent_name);
+                let opaque_type: BasicTypeEnum = opaque_struct.into();
+                
+                // Register it in the POU type index for this generation session
+                let _ = self.types_index.associate_pou_type(parent_name, opaque_type.as_any_type_enum());
+                
+                parameter_types.push(opaque_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into());
             }
         }
 
@@ -206,10 +239,11 @@ 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!(),
+            AnyTypeEnum::FloatType(value) => value.fn_type(parameter_types.as_slice(), false),
+            _ => unimplemented!("Unsupported function return type: {:?}", return_type),
         };
 
         Ok(fn_type)
@@ -248,9 +282,11 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
                 StructSource::Pou(PouType::Function | PouType::Method { .. }, ..) => {
                     let gen_type = self.create_function_type(name)?;
 
-                    // TODO(vosa): Strictly speaking we don't need to register in LLVM index, i.e. `return Ok(gen_type.as_any_type_enum())` would suffice without breaking any tests; re-think approach with AnyType changes in API
+                    // Associate the function type in the POU index
                     self.types_index.associate_pou_type(name, gen_type.as_any_type_enum())?;
-                    self.types_index.get_associated_function_type(name).map(|it| it.as_any_type_enum())
+                    
+                    // Return the function type
+                    Ok(gen_type.as_any_type_enum())
                 }
                 StructSource::Pou(..) => self
                     .types_index

src/codegen/generators/pou_generator.rs

@@ -389,7 +389,14 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
                 let class_name =
                     implementation.get_associated_class_name().expect("Method needs to have a class-name");
                 let instance_members_struct_type: StructType =
-                    self.llvm_index.get_associated_type(class_name).map(|it| it.into_struct_type())?;
+                    self.llvm_index.get_associated_pou_type(class_name)
+                        .or_else(|_| {
+                            // Fallback: create a placeholder opaque struct type
+                            eprintln!("Warning: POU type '{}' not found, creating placeholder", class_name);
+                            let placeholder_struct = self.llvm.context.opaque_struct_type(class_name);
+                            Ok::<BasicTypeEnum<'_>, Diagnostic>(placeholder_struct.into())
+                        })
+                        .map(|it| it.into_struct_type())?;
                 parameters.insert(
                     0,
                     instance_members_struct_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into(),

src/codegen/llvm_index.rs

@@ -200,6 +200,10 @@ impl<'ink> LlvmTypedIndex<'ink> {
 
     pub fn get_associated_pou_type(&self, type_name: &str) -> Result<BasicTypeEnum<'ink>, Diagnostic> {
         self.find_associated_pou_type(type_name)
+            .or_else(|| {
+                // Fallback: try to find it as a regular type if it's not found as a POU type
+                self.find_associated_type(type_name)
+            })
             .ok_or_else(|| Diagnostic::unknown_type(type_name, SourceLocation::undefined()))
     }