fix: annotate whole call statement

Previously when dealing with function pointer calls such as `fnPtr^()`
the resolver would only annotate the operator and any arguments. Some
codegen parts require an annotation on the whole call statement however
(which makes sense), as such this commit fixes the described issue.
Visuallized, assuming `fnPtr` points to a function returning a DINT:
```
fnPtr^();
^^^^^^^^ -> StatementAnnotation::Value { resulting_type: "DINT" }
```

Author: volsa

src/resolver.rs

@@ -2246,22 +2246,29 @@ impl<'i> TypeAnnotator<'i> {
             self.annotate_call_statement(operator, parameters_stmt, &ctx);
         };
 
-        if let Some(StatementAnnotation::Function { return_type, .. }) = self.annotation_map.get(operator) {
-            if let Some(return_type) = self
-                .index
-                .find_effective_type_by_name(return_type)
-                .or_else(|| self.annotation_map.new_index.find_effective_type_by_name(return_type))
-            {
-                if let Some(StatementAnnotation::ReplacementAst { .. }) = self.annotation_map.get(statement) {
-                    // if we have a replacement ast, we do not need to annotate the function return type as it would
-                    // overwrite the replacement ast
-                    return;
+        match self.annotation_map.get(operator) {
+            Some(StatementAnnotation::Function { return_type, .. })
+            | Some(StatementAnnotation::FunctionPointer { return_type, .. }) => {
+                if let Some(return_type) = self
+                    .index
+                    .find_effective_type_by_name(return_type)
+                    .or_else(|| self.annotation_map.new_index.find_effective_type_by_name(return_type))
+                {
+                    if let Some(StatementAnnotation::ReplacementAst { .. }) =
+                        self.annotation_map.get(statement)
+                    {
+                        // if we have a replacement ast, we do not need to annotate the function return type as it would
+                        // overwrite the replacement ast
+                        return;
+                    }
+                    self.annotate(statement, StatementAnnotation::value(return_type.get_name()));
+                } else {
+                    // Assuming this is a VOID function if no annotation is present
+                    self.annotate(statement, StatementAnnotation::value(VOID_INTERNAL_NAME));
                 }
-                self.annotate(statement, StatementAnnotation::value(return_type.get_name()));
-            } else {
-                // Assuming this is a VOID function if no annotation is present
-                self.annotate(statement, StatementAnnotation::value(VOID_INTERNAL_NAME));
             }
+
+            _ => (),
         }
     }
 

src/resolver/tests/fnptr.rs

@@ -50,7 +50,13 @@ fn function_pointer_method_with_no_arguments() {
 
         // echoPtr^();
         // ^^^^^^^^^^
-        insta::assert_debug_snapshot!(annotations.get(node), @"None");
+        insta::assert_debug_snapshot!(annotations.get(node), @r#"
+        Some(
+            Value {
+                resulting_type: "DINT",
+            },
+        )
+        "#);
     }
 }
 
@@ -112,7 +118,13 @@ fn function_pointer_method_with_arguments() {
 
         // echoPtr^();
         // ^^^^^^^^^^
-        insta::assert_debug_snapshot!(annotations.get(&statements[0]), @"None");
+        insta::assert_debug_snapshot!(annotations.get(&statements[0]), @r#"
+        Some(
+            Value {
+                resulting_type: "DINT",
+            },
+        )
+        "#);
     }
 
     // echoPtr^(instanceFb, localIn, localOut, localInOut);
@@ -193,6 +205,16 @@ fn function_pointer_method_with_arguments() {
             },
         )
         "#);
+
+        // echoPtr^(instanceFb, localIn, localOut, localInOut);
+        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        insta::assert_debug_snapshot!(annotations.get(&statements[1]), @r#"
+        Some(
+            Value {
+                resulting_type: "DINT",
+            },
+        )
+        "#);
     }
 
     // echoPtr^(instanceFb, in := localIn, out => localOut, inout := localInOut);
@@ -349,7 +371,7 @@ fn void_pointer_casting() {
                 __vtable: POINTER TO __VOID;
             END_VAR
 
-            METHOD foo
+            METHOD foo: DINT
             END_METHOD
         END_FUNCTION_BLOCK
 
@@ -416,13 +438,28 @@ fn void_pointer_casting() {
         insta::assert_debug_snapshot!(annotations.get(&call.operator), @r#"
         Some(
             FunctionPointer {
-                return_type: "VOID",
+                return_type: "DINT",
                 qualified_name: "FbA.foo",
             },
         )
         "#);
         insta::assert_debug_snapshot!(annotations.get_hint(&call.operator), @"None");
     }
+
+    {
+        let node = &unit.implementations.iter().find(|imp| imp.name == "main").unwrap().statements[1];
+
+        // vtable_FbA#(instanceFbA.__vtable).foo^(instanceFbA);
+        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        insta::assert_debug_snapshot!(annotations.get(&node), @r#"
+        Some(
+            Value {
+                resulting_type: "DINT",
+            },
+        )
+        "#);
+        insta::assert_debug_snapshot!(annotations.get_hint(&node), @"None");
+    }
 }
 
 #[test]