fix: stack-overflow safeguard for find_local_member (#1440)

* fix: add safe-guard against stack-overflow when 'find_local_member' calls 'find_member' recursively

* extend 'pou_with_two_types_not_considered_recursive' test

Author: mhasel

src/index.rs

@@ -1465,21 +1465,30 @@ impl Index {
         &self,
         container_name: &str,
         variable_name: &str,
+    ) -> Option<&VariableIndexEntry> {
+        self.find_local_member_recursive(container_name, variable_name, &mut FxHashSet::default())
+    }
+
+    fn find_local_member_recursive(
+        &self,
+        container_name: &str,
+        variable_name: &str,
+        seen: &mut FxHashSet<String>,
     ) -> Option<&VariableIndexEntry> {
         self.type_index
             .find_type(container_name)
             .and_then(|it| it.find_member(variable_name))
             .or(self.find_enum_variant_in_pou(container_name, variable_name))
-            // underlying type of an `ACTION`
+            // underlying type of an `ACTION` or `METHOD`
             .or(container_name
                 .rfind('.')
                 .map(|p| &container_name[..p])
-                .and_then(|qualifier| self.find_member(qualifier, variable_name)))
+                .and_then(|qualifier| self.find_member_recursive(qualifier, variable_name, seen)))
             // 'self' instance of a POUs init function
             .or(container_name
                 .rfind("__init_")
                 .map(|p| &container_name[p + 1..])
-                .and_then(|qualifier| self.find_member(qualifier, variable_name)))
+                .and_then(|qualifier| self.find_member_recursive(qualifier, variable_name, seen)))
     }
 
     /// Searches for variable name in the given container, if not found, attempts to search for it in super classes
@@ -1491,13 +1500,13 @@ impl Index {
         &'b self,
         container_name: &str,
         variable_name: &str,
-        seen: &mut FxHashSet<&'b str>,
+        seen: &mut FxHashSet<String>,
     ) -> Option<&'b VariableIndexEntry> {
         // Find pou in index
-        self.find_local_member(container_name, variable_name)
+        self.find_local_member_recursive(container_name, variable_name, seen)
             .or_else(|| {
                 if let Some(class) = self.find_pou(container_name).and_then(|it| it.get_super_class()) {
-                    if !seen.insert(class) {
+                    if !seen.insert(class.into()) {
                         return None;
                     }
                     self.find_member_recursive(class, variable_name, seen).filter(|it| !(it.is_temp()))

src/index/tests/index_tests.rs

@@ -2273,11 +2273,19 @@ fn pou_with_two_types_not_considered_recursive() {
             x : fb;
             y : fb;
         END_VAR
-        END_PROGRAM",
+            METHOD x : fb
+            END_METHOD
+        END_PROGRAM
+        
+        ACTION p.y
+        END_ACTION",
     );
 
     let pou_type = index.find_pou_type("p").unwrap();
     assert_eq!(pou_type.get_type_information().get_size(&index).unwrap().bits(), 64);
+
+    assert!(index.find_local_member("p", "x").is_some());
+    assert!(index.find_local_member("p", "y").is_some());
 }
 
 #[test]