Initial values on methods are passed correctly

compiler/plc_ast/src/ast.rs

@@ -318,7 +318,7 @@ impl PouType {
     }
 
     pub fn is_function_or_init(&self) -> bool {
-        matches!(self, PouType::Function | PouType::Init | PouType::ProjectInit)
+        matches!(self, PouType::Function | PouType::Init | PouType::ProjectInit | PouType::Method { .. })
     }
 }
 

compiler/plc_diagnostics/src/diagnostics/diagnostics_registry.rs

@@ -150,7 +150,7 @@ lazy_static! {
         E046,   Error,      include_str!("./error_codes/E046.md"),
         E047,   Warning,    include_str!("./error_codes/E047.md"), // VLAs are always by reference
         E048,   Error,      include_str!("./error_codes/E048.md"),
-        E049,   Error,      include_str!("./error_codes/E049.md"),
+        E049,   Warning,    include_str!("./error_codes/E049.md"),
         E050,   Error,      include_str!("./error_codes/E050.md"),
         E051,   Error,      include_str!("./error_codes/E051.md"),
         E052,   Error,      include_str!("./error_codes/E052.md"),

src/codegen/generators/expression_generator.rs

@@ -558,7 +558,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         // after the call we need to copy the values for assigned outputs
         // this is only necessary for outputs defined as `rusty::index::ArgumentType::ByVal` (PROGRAM, FUNCTION_BLOCK)
         // FUNCTION outputs are defined as `rusty::index::ArgumentType::ByRef` // FIXME(mhasel): for standard-compliance functions also need to support VAR_OUTPUT
-        if !pou.is_function() {
+        if !(pou.is_function() || pou.is_method()) {
             let parameter_struct = match arguments_list.first() {
                 Some(v) => v.into_pointer_value(),
                 None => self.generate_lvalue(operator)?,
@@ -833,52 +833,54 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         operator: &AstNode,
         function_context: &'b FunctionContext<'ink, 'b>,
     ) -> Result<Vec<BasicMetadataValueEnum<'ink>>, Diagnostic> {
-        let arguments_list = if matches!(pou, PouIndexEntry::Function { .. }) {
-            // we're calling a function
-            let declared_parameters = self.index.get_declared_parameters(implementation.get_type_name());
-            self.generate_function_arguments(pou, passed_parameters, declared_parameters)?
-        } else {
-            // no function
-            let (class_ptr, call_ptr) = match pou {
-                PouIndexEntry::Method { .. } => {
-                    let class_ptr = self.generate_lvalue(operator).or_else(|_| {
-                        // this might be a local method
-                        function_context
-                            .function
-                            .get_first_param()
-                            .map(|class_ptr| class_ptr.into_pointer_value())
-                            .ok_or_else(|| Diagnostic::cannot_generate_call_statement(operator))
-                    })?;
-                    let call_ptr =
-                        self.allocate_function_struct_instance(implementation.get_call_name(), operator)?;
-                    (Some(class_ptr), call_ptr)
-                }
-                // TODO: find a more reliable way to make sure if this is a call into a local action!!
-                PouIndexEntry::Action { .. }
-                    if try_from!(operator, ReferenceExpr).is_some_and(|it| it.base.is_none()) =>
-                {
-                    // special handling for local actions, get the parameter from the function context
+        match pou {
+            PouIndexEntry::Function { .. } => {
+                // we're calling a function
+                let declared_parameters = self.index.get_declared_parameters(implementation.get_type_name());
+                self.generate_function_arguments(pou, passed_parameters, declared_parameters)
+            }
+            PouIndexEntry::Method { .. } => {
+                let class_ptr = self.generate_lvalue(operator).or_else(|_| {
+                    // this might be a local method
                     function_context
                         .function
                         .get_first_param()
-                        .map(|call_ptr| (None, call_ptr.into_pointer_value()))
-                        .ok_or_else(|| Diagnostic::cannot_generate_call_statement(operator))?
-                }
-                _ => {
-                    let call_ptr = self.generate_lvalue(operator)?;
-                    (None, call_ptr)
-                }
-            };
-
-            // generate the pou call assignments
-            self.generate_stateful_pou_arguments(
-                implementation.get_call_name(),
-                class_ptr,
-                call_ptr,
-                passed_parameters,
-            )?
-        };
-        Ok(arguments_list)
+                        .map(|class_ptr| class_ptr.into_pointer_value())
+                        .ok_or_else(|| Diagnostic::cannot_generate_call_statement(operator))
+                })?;
+                let declared_parameters = self.index.get_declared_parameters(implementation.get_type_name());
+                let mut parameters =
+                    self.generate_function_arguments(pou, passed_parameters, declared_parameters)?;
+                parameters.insert(0, class_ptr.into());
+                Ok(parameters)
+            }
+            PouIndexEntry::Action { .. }
+                if try_from!(operator, ReferenceExpr).is_some_and(|it| it.base.is_none()) =>
+            {
+                // special handling for local actions, get the parameter from the function context
+                let call_ptr = function_context
+                    .function
+                    .get_first_param()
+                    .map(|call_ptr| call_ptr.into_pointer_value())
+                    .ok_or_else(|| Diagnostic::cannot_generate_call_statement(operator))?;
+
+                self.generate_stateful_pou_arguments(
+                    implementation.get_call_name(),
+                    None,
+                    call_ptr,
+                    passed_parameters,
+                )
+            }
+            _ => {
+                let call_ptr = self.generate_lvalue(operator)?;
+                self.generate_stateful_pou_arguments(
+                    implementation.get_call_name(),
+                    None,
+                    call_ptr,
+                    passed_parameters,
+                )
+            }
+        }
     }
 
     fn generate_function_arguments(
@@ -1142,27 +1144,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         }
     }
 
-    // TODO: will be deleted once methods work properly (like functions)
-    /// generates a new instance of a function called `function_name` and returns a PointerValue to it
-    ///
-    /// - `function_name` the name of the function as registered in the index
-    /// - `context` the statement used to report a possible Diagnostic on
-    fn allocate_function_struct_instance(
-        &self,
-        function_name: &str,
-        context: &AstNode,
-    ) -> Result<PointerValue<'ink>, Diagnostic> {
-        let instance_name = format!("{function_name}_instance"); // TODO: Naming convention (see plc_util/src/convention.rs)
-        let function_type = self
-            .llvm_index
-            .find_associated_pou_type(function_name) //Using find instead of get to control the compile error
-            .ok_or_else(|| {
-                Diagnostic::codegen_error(format!("No type associated with '{instance_name:}'"), context)
-            })?;
-
-        Ok(self.llvm.create_local_variable(&instance_name, &function_type))
-    }
-
     /// generates the assignments of a pou-call's parameters
     /// the call parameters are passed to the pou using a struct-instance with all the parameters
     ///

src/codegen/generators/pou_generator.rs

@@ -205,8 +205,10 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
         new_llvm_index: &mut LlvmTypedIndex<'ink>,
     ) -> Result<FunctionValue<'ink>, Diagnostic> {
         let declared_parameters = self.index.get_declared_parameters(implementation.get_call_name());
-        let parameters = self
-            .collect_parameters_for_implementation(implementation)?
+        let mut parameters = self.collect_parameters_for_implementation(implementation)?;
+        // if we are handling a method, take the first parameter as the instance
+        let instance = if implementation.is_method() { Some(parameters.remove(0)) } else { None };
+        let mut parameters = parameters
             .iter()
             .enumerate()
             .map(|(i, p)| {
@@ -257,6 +259,10 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
                 }
             })
             .collect::<Vec<BasicMetadataTypeEnum>>();
+        // insert the instance as the first parameter
+        if let Some(instance) = instance {
+            parameters.insert(0, instance);
+        }
 
         let return_type = self
             .index
@@ -350,15 +356,6 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
     ) -> Result<Vec<BasicMetadataTypeEnum<'ink>>, Diagnostic> {
         if !implementation.implementation_type.is_function_or_init() {
             let mut parameters = vec![];
-            if implementation.get_implementation_type() == &ImplementationType::Method {
-                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())?;
-                parameters.push(
-                    instance_members_struct_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into(),
-                );
-            }
             let instance_struct_type: StructType = self
                 .llvm_index
                 .get_associated_pou_type(implementation.get_type_name())
@@ -368,12 +365,24 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
             Ok(parameters)
         } else {
             let declared_params = self.index.get_declared_parameters(implementation.get_call_name());
-
             //find the function's parameters
-            declared_params
+            let mut parameters = declared_params
                 .iter()
                 .map(|v| self.llvm_index.get_associated_type(v.get_type_name()).map(Into::into))
-                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()
+                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?;
+
+            if implementation.get_implementation_type() == &ImplementationType::Method {
+                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())?;
+                parameters.insert(
+                    0,
+                    instance_members_struct_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into(),
+                );
+            }
+
+            Ok(parameters)
         }
     }
 
@@ -551,6 +560,10 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
         // cannot use index from members because return and temp variables may not be considered for index in build_struct_gep
         // eagerly handle the return-variable
         let mut params_iter = function_context.function.get_param_iter();
+        // if we are in a method, skip the first parameter (the instance)
+        if matches!(function_context.linking_context.get_implementation_type(), ImplementationType::Method) {
+            params_iter.next();
+        }
         if let Some(ret_v) = members.iter().find(|it| it.is_return()) {
             let return_type = index.get_associated_type(ret_v.get_type_name())?;
             let return_variable = self.llvm.create_local_variable(type_name, &return_type);