fix: make sure actions called from other actions get resolved (#980)

Author: ghaith

compiler/plc_driver/src/runner.rs

@@ -38,7 +38,6 @@ pub fn compile<T: Compilable>(context: &CodegenContext, source: T) -> GeneratedM
         ..Default::default()
     };
 
-    dbg!(&annotated_project.units[0].0);
     annotated_project.generate_single_module(context, &compile_options).unwrap().unwrap()
 }
 

src/resolver.rs

@@ -1980,7 +1980,10 @@ impl ResolvingScope {
                     index.find_pou(name).and_then(|pou| to_pou_annotation(pou, index)).or_else(|| {
                         ctx.pou.and_then(|pou|
                                 // retry with local pou as qualifier
-                                ResolvingScope::POU.resolve_name(name, Some(pou), index, ctx))
+                                //Use the type name of the pou in case we are resolving a
+                                //neighboring action
+                                index.find_pou(pou).map(|pou| pou.get_container())
+                                .and_then(|pou|ResolvingScope::POU.resolve_name(name, Some(pou), index, ctx)))
                     })
                 }
             }

src/resolver/tests/resolve_expressions_tests.rs

@@ -4279,6 +4279,48 @@ fn action_call_statement_parameters_are_annotated_with_a_type_hint() {
     }
 }
 
+#[test]
+fn action_called_from_other_action_resolved() {
+    let id_provider = IdProvider::default();
+    let (unit, mut index) = index_with_ids(
+        r#"
+        PROGRAM mainProg
+        VAR
+        END_VAR
+            act1();
+        END_PROGRAM
+
+        ACTIONS
+        ACTION act1
+            act2();
+        END_ACTION
+        ACTION act2
+            act1();
+        END_ACTION
+        END_ACTIONS
+        "#,
+        id_provider.clone(),
+    );
+
+    let annotations = annotate_with_ids(&unit, &mut index, id_provider);
+
+    //Actions are annotated corretly
+    let AstStatement::CallStatement(CallStatement { operator, .. }) = unit.implementations[0].statements[0].get_stmt() else {
+        unreachable!()
+    };
+    assert_eq!(annotations.get_call_name(operator).unwrap(), "mainProg.act1");
+
+    let AstStatement::CallStatement(CallStatement { operator, .. }) = unit.implementations[1].statements[0].get_stmt() else {
+        unreachable!()
+    };
+    assert_eq!(annotations.get_call_name(operator).unwrap(), "mainProg.act2");
+
+    let AstStatement::CallStatement(CallStatement { operator, .. }) = unit.implementations[2].statements[0].get_stmt() else {
+        unreachable!()
+    };
+    assert_eq!(annotations.get_call_name(operator).unwrap(), "mainProg.act1");
+}
+
 #[test]
 fn vla_struct_reference_is_annotated_as_array() {
     let id_provider = IdProvider::default();

src/test_utils.rs

@@ -105,7 +105,6 @@ pub mod tests {
 
     pub fn parse_and_validate_buffered(src: &str) -> String {
         let diagnostics = parse_and_validate(src);
-        dbg!(&diagnostics);
         let mut reporter = Diagnostician::buffered();
 
         reporter.register_file("<internal>".to_string(), src.to_string());

src/validation/tests/variable_length_array_test.rs

@@ -64,7 +64,7 @@ mod program {
     #[test]
     fn variable_length_array_program_input_ref() {
         let program = SOURCE.replace("<POU_TYPE>", "PROGRAM");
-        let program_input = parse_and_validate(dbg!(&program.replace("<VAR_TYPE>", "INPUT {ref}")));
+        let program_input = parse_and_validate(&program.replace("<VAR_TYPE>", "INPUT {ref}"));
         assert_validation_snapshot!(program_input);
     }