refactor: Introduce StatementAnnotation::FunctionPointer

volsa · volsa · commit e73887c5f96f · 2025-07-31T16:47:57.000+02:00
Previously function pointers were annotated using the `Value` variant which has been changed with this commit.
diff --git a/compiler/plc_diagnostics/src/diagnostics.rs b/compiler/plc_diagnostics/src/diagnostics.rs
@@ -280,6 +280,7 @@ impl Diagnostic {
 
     pub fn cannot_generate_call_statement(operator: &AstNode) -> Diagnostic {
         //TODO: We could probably get a better slice here
+        // todo!();
         Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
     }
 
diff --git a/src/codegen/generators/data_type_generator.rs b/src/codegen/generators/data_type_generator.rs
@@ -189,6 +189,8 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
             .map(|opt| opt.as_any_type_enum())
             .unwrap_or(self.llvm.context.void_type().into());
 
+        dbg!(&return_type);
+
         let mut parameter_types = vec![];
 
         // We need to add the POU type as the first parameter when dealing with methods
diff --git a/src/codegen/generators/expression_generator.rs b/src/codegen/generators/expression_generator.rs
@@ -535,6 +535,8 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 panic!("{implementation:#?}");
             };
 
+        dbg!(method_instance, actual_parameters);
+
         // TODO: Why alloca?
         // %fnPtr = alloca void (%FbA*)*, align 8
         let function_pointer_value = self.generate_expression_value(base)?;
@@ -617,12 +619,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         operator: &AstNode,
         parameters: Option<&AstNode>,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
-        if operator.is_deref()
-            && self
-                .annotations
-                .get_type(operator, self.index)
-                .is_some_and(|opt| opt.is_method_pointer(self.index))
-        {
+        if operator.is_deref() && self.annotations.get(operator).is_some_and(StatementAnnotation::is_fnptr) {
             return self.generate_function_pointer_call(operator, parameters);
         }
 
diff --git a/src/codegen/tests/function_pointer_tests.rs b/src/codegen/tests/function_pointer_tests.rs
@@ -145,7 +145,7 @@ fn function_pointer_method_with_input_output_inout() {
       store i16 0, i16* %localInOutVariable, align 2
       store void (%FbA*, i16, i16*, i16*)* @FbA__foo, void (%FbA*, i16, i16*, i16*)** %fnPtr, align 8
       %1 = load void (%FbA*, i16, i16*, i16*)*, void (%FbA*, i16, i16*, i16*)** %fnPtr, align 8
-      call void %1(%FbA* %instanceFbA, i16 12345, i16* %localOutVariable, i16* %localInOutVariable)
+      call void %1(%FbA* %instanceFbA, i32 12345, i16* %localOutVariable, i16* %localInOutVariable)
       %2 = load void (%FbA*, i16, i16*, i16*)*, void (%FbA*, i16, i16*, i16*)** %fnPtr, align 8
       %load_localInVariable = load i16, i16* %localInVariable, align 2
       call void %2(%FbA* %instanceFbA, i16 %load_localInVariable, i16* %localOutVariable, i16* %localInOutVariable)
diff --git a/src/lowering/calls.rs b/src/lowering/calls.rs
@@ -60,7 +60,10 @@ use plc_ast::{
 };
 use plc_source::source_location::SourceLocation;
 
-use crate::{index::Index, resolver::AnnotationMap};
+use crate::{
+    index::Index,
+    resolver::{AnnotationMap, StatementAnnotation},
+};
 
 #[derive(Default, Debug, Clone)]
 struct VisitorContext {
@@ -272,16 +275,30 @@ impl AstVisitorMut for AggregateTypeLowerer {
             //Early exit if not annotated or indexed
             return;
         };
-        //Get the function being called
-        let Some(crate::resolver::StatementAnnotation::Function {
-            qualified_name,
-            return_type: return_type_name,
-            generic_name,
-            ..
-        }) = annotation.get(&stmt.operator).or_else(|| annotation.get_hint(&stmt.operator)).cloned()
-        else {
-            return;
+        // //Get the function being called
+        // let Some(crate::resolver::StatementAnnotation::Function {
+        //     qualified_name,
+        //     return_type: return_type_name,
+        //     generic_name,
+        //     ..
+        // }) = annotation.get(&stmt.operator).or_else(|| annotation.get_hint(&stmt.operator)).cloned()
+        // else {
+        //     return;
+        // };
+        let (qualified_name, return_type_name, generic_name) = match annotation
+            .get(&stmt.operator)
+            .or_else(|| annotation.get_hint(&stmt.operator))
+            .cloned()
+        {
+            Some(StatementAnnotation::Function { return_type, qualified_name, generic_name, call_name }) => {
+                (qualified_name, return_type, generic_name)
+            }
+            Some(StatementAnnotation::FunctionPointer { return_type, qualified_name }) => {
+                (qualified_name, return_type, None)
+            }
+            _ => return,
         };
+
         //If there's a call name in the function, it is a generic and needs to be replaced.
         //HACK: this is because we don't lower generics
         let function_entry = index.find_pou(&qualified_name).expect("Function not found");
diff --git a/src/resolver.rs b/src/resolver.rs
@@ -474,6 +474,15 @@ pub enum StatementAnnotation {
         /// The call name of the function iff it differs from the qualified name (generics)
         call_name: Option<String>,
     },
+    FunctionPointer {
+        /// The defined return type of the function
+        return_type: String,
+        /// The defined qualified name of the function
+        qualified_name: String,
+        // TODO: Is this needed?
+        // The call name of the function iff it differs from the qualified name (generics)
+        // call_name: Option<String>,
+    },
     /// a reference to a type (e.g. `INT`)
     Type {
         type_name: String,
@@ -676,6 +685,17 @@ impl StatementAnnotation {
         StatementAnnotation::Value { resulting_type: type_name.into() }
     }
 
+    pub fn fnptr<T, U>(return_ty: T, qualified_name: U) -> Self
+    where
+        T: Into<String>,
+        U: Into<String>,
+    {
+        StatementAnnotation::FunctionPointer {
+            return_type: return_ty.into(),
+            qualified_name: qualified_name.into(),
+        }
+    }
+
     pub fn create_override(definitions: Vec<MethodDeclarationType>) -> Self {
         StatementAnnotation::Override { definitions }
     }
@@ -721,6 +741,10 @@ impl StatementAnnotation {
         matches!(self, StatementAnnotation::Property { .. })
     }
 
+    pub fn is_fnptr(&self) -> bool {
+        matches!(self, StatementAnnotation::FunctionPointer { .. })
+    }
+
     pub fn qualified_name(&self) -> Option<&str> {
         match self {
             StatementAnnotation::Variable { qualified_name, .. }
@@ -851,6 +875,7 @@ pub trait AnnotationMap {
             | StatementAnnotation::Super { name: qualified_name, .. } => Some(qualified_name.as_str()),
             StatementAnnotation::Type { type_name } => Some(type_name),
             StatementAnnotation::Function { qualified_name, .. } => Some(qualified_name),
+            StatementAnnotation::FunctionPointer { qualified_name, .. } => Some(qualified_name),
             StatementAnnotation::Label { .. }
             | StatementAnnotation::Override { .. }
             | StatementAnnotation::MethodDeclarations { .. }
@@ -2029,12 +2054,15 @@ impl<'i> TypeAnnotator<'i> {
                         .find_effective_type_by_name(inner_type_name)
                         .or(self.annotation_map.new_index.find_effective_type_by_name(inner_type_name))
                     {
-                        // TODO(vosa): also add is_method() check
                         // We're dealing with a function pointer, hence annotate the deref node with the variables name
-                        if inner_type.get_type_information().is_function()
-                            || inner_type.get_type_information().is_method()
-                        {
-                            self.annotate(stmt, StatementAnnotation::value(name));
+                        // XXX: Functions are intentionally ignored here for now, as the feature as of writing
+                        //      this comment is only interesting for methods due to polymorphism.
+                        if inner_type.get_type_information().is_method() {
+                            let pou = self.index.find_pou(&inner_type.name).unwrap();
+                            self.annotate(
+                                stmt,
+                                StatementAnnotation::fnptr(pou.get_return_type().unwrap(), pou.get_name()),
+                            )
                         } else {
                             self.annotate(stmt, StatementAnnotation::value(inner_type.get_name()))
                         }
@@ -2223,6 +2251,9 @@ impl<'i> TypeAnnotator<'i> {
                 StatementAnnotation::Function { qualified_name, call_name, .. } => {
                     call_name.as_ref().cloned().or_else(|| Some(qualified_name.clone()))
                 }
+                StatementAnnotation::FunctionPointer { qualified_name, .. } => {
+                    Some(qualified_name.to_string())
+                }
                 StatementAnnotation::Program { qualified_name } => Some(qualified_name.clone()),
                 StatementAnnotation::Variable { resulting_type, .. } => self
                     .index
@@ -2243,24 +2274,7 @@ impl<'i> TypeAnnotator<'i> {
                         AstStatement::ReferenceExpr(
                             ReferenceExpr { access: ReferenceAccess::Deref, .. },
                             ..,
-                        ) => {
-                            let mut resulting_type = resulting_type.to_string();
-
-                            // When dealing with a pointer, we have to fetch the target type
-                            if let Some(DataTypeInformation::Pointer { inner_type_name, .. }) = self
-                                .index
-                                .find_effective_type_by_name(&resulting_type)
-                                .map(|opt| opt.get_type_information())
-                            {
-                                resulting_type = self
-                                    .index
-                                    .find_pou(inner_type_name)
-                                    .map(|opt| opt.get_name().to_string())
-                                    .expect("must exist")
-                            }
-
-                            self.index.find_pou(resulting_type.as_str()).map(|it| it.get_name().to_string())
-                        }
+                        ) => self.index.find_pou(resulting_type.as_str()).map(|it| it.get_name().to_string()),
 
                         _ => None,
                     }
diff --git a/src/resolver/tests/function_pointer_tests.rs b/src/resolver/tests/function_pointer_tests.rs
diff --git a/src/validation/statement.rs b/src/validation/statement.rs

Original file line number	Diff line number	Diff line change
`@@ -280,6 +280,7 @@ impl Diagnostic {`
`280`	`280`
`281`	`281`	`pub fn cannot_generate_call_statement(operator: &AstNode) -> Diagnostic {`
`282`	`282`	`//TODO: We could probably get a better slice here`
	`283`	`+ // todo!();`
`283`	`284`	`Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)`
`284`	`285`	`}`
`285`	`286`