refactor: Introduce StatementAnnotation::Argument (#1470)

Identical to `StatementAnnotation::Value` with an additional `position` field indicating the position of a parameter in an POU. Helpful for codegen later on when generating the arguments of a function call for implicit calls.

Author: volsa

compiler/plc_ast/src/ast.rs

@@ -1269,13 +1269,13 @@ impl AstNode {
     pub fn has_super_metadata(&self) -> bool {
         self.get_metadata()
             .or_else(|| self.get_identifier().and_then(|it| it.get_metadata()))
-            .map_or(false, |it| it.is_super())
+            .is_some_and(|it| it.is_super())
     }
 
     pub fn has_super_metadata_deref(&self) -> bool {
         self.get_metadata()
             .or_else(|| self.get_identifier().and_then(|it| it.get_metadata()))
-            .map_or(false, |it| it.is_super_deref())
+            .is_some_and(|it| it.is_super_deref())
     }
 
     pub fn can_be_assigned_to(&self) -> bool {

src/codegen/generators/expression_generator.rs

@@ -590,7 +590,11 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 self.assign_output_value(&CallParameterAssignment {
                     assignment: assignment_statement,
                     function_name,
-                    index: index as u32,
+                    index: self
+                        .annotations
+                        .get_hint(assignment_statement)
+                        .and_then(StatementAnnotation::get_location_in_parent)
+                        .expect("arguments must have a type hint"),
                     parameter_struct,
                 })?
             }
@@ -886,14 +890,14 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
     fn generate_function_arguments(
         &self,
         pou: &PouIndexEntry,
-        passed_parameters: &[&AstNode],
+        arguments: &[&AstNode],
         declared_parameters: Vec<&VariableIndexEntry>,
     ) -> Result<Vec<BasicMetadataValueEnum<'ink>>, Diagnostic> {
         let mut result = Vec::new();
         let mut variadic_parameters = Vec::new();
         let mut passed_param_indices = Vec::new();
-        for (i, parameter) in passed_parameters.iter().enumerate() {
-            let (i, parameter, _) = get_implicit_call_parameter(parameter, &declared_parameters, i)?;
+        for (i, argument) in arguments.iter().enumerate() {
+            let (i, parameter, _) = get_implicit_call_parameter(argument, &declared_parameters, i)?;
 
             // parameter_info includes the declaration type and type name
             let parameter_info = declared_parameters
@@ -1155,18 +1159,22 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         pou_name: &str,
         class_struct: Option<PointerValue<'ink>>,
         parameter_struct: PointerValue<'ink>,
-        passed_parameters: &[&AstNode],
+        arguments: &[&AstNode],
     ) -> Result<Vec<BasicMetadataValueEnum<'ink>>, Diagnostic> {
         let mut result = class_struct
             .map(|class_struct| {
                 vec![class_struct.as_basic_value_enum().into(), parameter_struct.as_basic_value_enum().into()]
             })
             .unwrap_or_else(|| vec![parameter_struct.as_basic_value_enum().into()]);
-        for (i, stmt) in passed_parameters.iter().enumerate() {
+        for argument in arguments.iter() {
             let parameter = self.generate_call_struct_argument_assignment(&CallParameterAssignment {
-                assignment: stmt,
+                assignment: argument,
                 function_name: pou_name,
-                index: i as u32,
+                index: self
+                    .annotations
+                    .get_hint(argument)
+                    .and_then(StatementAnnotation::get_location_in_parent)
+                    .expect("arguments must have a type hint"),
                 parameter_struct,
             })?;
             if let Some(parameter) = parameter {

src/codegen/tests/directaccess_test.rs

@@ -141,7 +141,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
         ",
     );
 
-    assert_snapshot!(ir, @r#"
+    assert_snapshot!(ir, @r###"
     ; ModuleID = '<internal>'
     source_filename = "<internal>"
 
@@ -218,7 +218,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
     declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #0
 
     attributes #0 = { argmemonly nofree nounwind willreturn }
-    "#);
+    "###);
 }
 
 #[test]
@@ -305,7 +305,7 @@ fn direct_acess_in_output_assignment_with_simple_expression_implicit() {
         ",
     );
 
-    assert_snapshot!(ir, @r#"
+    assert_snapshot!(ir, @r###"
     ; ModuleID = '<internal>'
     source_filename = "<internal>"
 
@@ -344,7 +344,7 @@ fn direct_acess_in_output_assignment_with_simple_expression_implicit() {
     declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #0
 
     attributes #0 = { argmemonly nofree nounwind willreturn }
-    "#);
+    "###);
 }
 
 #[test]

src/codegen/tests/parameters_tests.rs

@@ -1025,7 +1025,7 @@ fn by_value_fb_arg_aggregates_are_memcopied() {
         "#,
     );
 
-    assert_snapshot!(result, @r#"
+    assert_snapshot!(result, @r###"
     ; ModuleID = '<internal>'
     source_filename = "<internal>"
 
@@ -1077,7 +1077,7 @@ fn by_value_fb_arg_aggregates_are_memcopied() {
 
     attributes #0 = { argmemonly nofree nounwind willreturn writeonly }
     attributes #1 = { argmemonly nofree nounwind willreturn }
-    "#);
+    "###);
 }
 
 #[test]

src/index.rs

@@ -700,24 +700,19 @@ pub enum PouIndexEntry {
 }
 
 impl PouIndexEntry {
-    pub fn get_method_name(&self) -> String {
+    pub fn get_method_name(&self) -> Option<String> {
         match self {
             PouIndexEntry::Method { property: Some((name, kind)), .. } => {
                 let kind = kind.to_string().to_uppercase();
-                format!("Property `{name}` ({kind})")
+                Some(format!("Property `{name}` ({kind})"))
             }
 
             PouIndexEntry::Method { name, .. } => {
                 let name = name.rsplit_once('.').map(|(_, rhs)| rhs).unwrap_or_default();
-                format!("Method `{name}`")
+                Some(format!("Method `{name}`"))
             }
 
-            _ => unreachable!(
-                "
-                *>yfw reading the name of this method*
-                https://i.pinimg.com/originals/47/8c/fe/478cfec0807b19eb0d96073c0301c82d.gif
-                "
-            ),
+            _ => None,
         }
     }
 }

src/resolver.rs

@@ -304,14 +304,14 @@ impl TypeAnnotator<'_> {
         } else {
             vec![]
         };
-        let operator_qualifier = &self.get_call_name(operator);
 
         let mut generics_candidates: FxHashMap<String, Vec<String>> = FxHashMap::default();
         let mut params = vec![];
         let mut parameters = parameters.into_iter();
 
         // If we are dealing with an action call statement, we need to get the declared parameters from the parent POU in order
         // to annotate them with the correct type hint.
+        let operator_qualifier = &self.get_call_name(operator);
         let implementation = self.index.find_implementation_by_name(operator_qualifier);
         let operator_qualifier = implementation.map(|it| it.get_type_name()).unwrap_or(operator_qualifier);
         for m in self.index.get_declared_parameters(operator_qualifier).into_iter() {
@@ -322,7 +322,7 @@ impl TypeAnnotator<'_> {
                 {
                     generics_candidates.entry(key.to_string()).or_default().push(candidate.to_string())
                 } else {
-                    params.push((p, type_name.to_string()))
+                    params.push((p, type_name.to_string(), m.get_location_in_parent()))
                 }
             }
         }
@@ -331,9 +331,8 @@ impl TypeAnnotator<'_> {
         match self.index.find_pou(operator_qualifier) {
             Some(pou) if pou.is_variadic() => {
                 //get variadic argument type, if it is generic, update the generic candidates
-                if let Some(type_name) =
-                    self.index.get_variadic_member(pou.get_name()).map(VariableIndexEntry::get_type_name)
-                {
+                if let Some(variadic) = self.index.get_variadic_member(pou.get_name()) {
+                    let type_name = variadic.get_type_name();
                     for parameter in parameters {
                         if let Some((key, candidate)) = TypeAnnotator::get_generic_candidate(
                             self.index,
@@ -383,17 +382,23 @@ impl TypeAnnotator<'_> {
                                 type_name
                             };
 
-                            params.push((parameter, type_name.to_string()));
+                            params.push((
+                                parameter,
+                                type_name.to_string(),
+                                variadic.get_location_in_parent(),
+                            ));
                         }
                     }
                 }
             }
             _ => {}
         }
-        for (p, name) in params {
-            self.annotate_parameters(p, &name);
+
+        for (p, name, position) in params {
+            self.annotate_parameters(p, &name, position as usize);
         }
-        //Attempt to resolve the generic signature here
+
+        // Attempt to resolve the generic signature here
         self.update_generic_call_statement(
             generics_candidates,
             operator_qualifier,
@@ -437,6 +442,14 @@ pub enum StatementAnnotation {
     Value {
         resulting_type: String,
     },
+    /// An argument of a call statement
+    Argument {
+        /// The resulting type of this argument
+        resulting_type: String,
+
+        /// The position of the parameter this argument is assigned to
+        position: usize,
+    },
     /// a reference that resolves to a declared variable (e.g. `a` --> `PLC_PROGRAM.a`)
     Variable {
         /// the name of the variable's type (e.g. `"INT"`)
@@ -717,6 +730,27 @@ impl StatementAnnotation {
             _ => None,
         }
     }
+
+    /// Returns the location of a parameter in some POU the argument is assigned to, for example
+    /// `foo(a, b, c)` will return `0` for `a`, `1` for `b` and `3` for c if `foo` has the following variable
+    /// blocks
+    /// ```norun
+    /// VAR_INPUT
+    ///     a, b : DINT;
+    /// END_VAR
+    /// VAR
+    ///     placeholder: DINT;
+    /// END_VAR
+    /// VAR_INPUT
+    ///     c : DINT;
+    /// END_VAR`
+    /// ```
+    pub(crate) fn get_location_in_parent(&self) -> Option<u32> {
+        match self {
+            StatementAnnotation::Argument { position, .. } => Some(*position as u32),
+            _ => None,
+        }
+    }
 }
 
 impl From<&PouIndexEntry> for StatementAnnotation {
@@ -807,6 +841,7 @@ pub trait AnnotationMap {
     fn get_type_name_for_annotation<'a>(&'a self, annotation: &'a StatementAnnotation) -> Option<&'a str> {
         match annotation {
             StatementAnnotation::Value { resulting_type } => Some(resulting_type.as_str()),
+            StatementAnnotation::Argument { resulting_type, .. } => Some(resulting_type.as_str()),
             StatementAnnotation::Variable { resulting_type, .. } => Some(resulting_type.as_str()),
             StatementAnnotation::ReplacementAst { statement } => self
                 .get_hint(statement)
@@ -2133,10 +2168,9 @@ impl<'i> TypeAnnotator<'i> {
                 }
                 StatementAnnotation::Program { qualified_name } => Some(qualified_name.clone()),
                 StatementAnnotation::Variable { resulting_type, .. } => {
-                    //lets see if this is a FB
                     self.index
                         .find_pou(resulting_type.as_str())
-                        .filter(|it| matches!(it, PouIndexEntry::FunctionBlock { .. }))
+                        .filter(|it| matches!(it, PouIndexEntry::FunctionBlock { .. } | PouIndexEntry::Program { .. }))
                         .map(|it| it.get_name().to_string())
                 }
                 // call statements on array access "arr[1]()" will return a StatementAnnotation::Value
@@ -2158,18 +2192,17 @@ impl<'i> TypeAnnotator<'i> {
         operator_qualifier
     }
 
-    pub(crate) fn annotate_parameters(&mut self, p: &AstNode, type_name: &str) {
-        if !matches!(
-            p.get_stmt(),
-            AstStatement::Assignment(..)
-                | AstStatement::OutputAssignment(..)
-                | AstStatement::RefAssignment(..)
-        ) {
-            if let Some(effective_member_type) = self.index.find_effective_type_by_name(type_name) {
-                //update the type hint
-                self.annotation_map
-                    .annotate_type_hint(p, StatementAnnotation::value(effective_member_type.get_name()))
-            }
+    pub(crate) fn annotate_parameters(&mut self, p: &AstNode, type_name: &str, position: usize) {
+        if let Some(effective_member_type) = self.index.find_effective_type_by_name(type_name) {
+            //update the type hint
+            // self.annotation_map.annotate_type_hint(p, StatementAnnotation::value(effective_member_type.get_name()))
+            self.annotation_map.annotate_type_hint(
+                p,
+                StatementAnnotation::Argument {
+                    resulting_type: effective_member_type.get_name().to_string(),
+                    position,
+                },
+            );
         }
     }