Merge pull request #23 from smythi93/dev

enhance DefUseFactory with thread-safe scope management and improve v…

Author: smythi93

src/sflkit/analysis/factory.py

@@ -85,7 +85,7 @@ def get_analysis(
                 if key not in self.objects:
                     self.objects[key] = Line(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class BranchFactory(AnalysisFactory):
@@ -117,7 +117,7 @@ def get_analysis(
                 return [self.objects[key], self.objects[else_key]]
             return [self.objects[key]]
 
-        return None
+        return []
 
 
 class FunctionFactory(AnalysisFactory):
@@ -130,7 +130,7 @@ def get_analysis(
                 if key not in self.objects:
                     self.objects[key] = Function(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class LoopFactory(AnalysisFactory):
@@ -170,80 +170,106 @@ def get_analysis(
             elif event.event_type == EventType.LOOP_END:
                 return self.objects[key][:]
             return list()
-        return None
+        return []
 
 
 class DefUseFactory(AnalysisFactory):
+    class DefScope:
+        def __init__(self, parent: "DefUseFactory.DefScope" = None):
+            self.parent: "DefUseFactory.DefScope" = parent
+            self.def_events: dict[tuple[str, int], DefEvent] = dict()
+
+        def enter(self):
+            return DefUseFactory.DefScope(self)
+
+        def exit(self):
+            return self.parent or self
+
+        def add(self, var_name: str, var_id: int, def_event: DefEvent):
+            self.def_events[(var_name, var_id)] = def_event
+
+        def event(self, var_name: str, var_id: int) -> DefEvent:
+            current = self
+            while current is not None:
+                if (var_name, var_id) in current.def_events:
+                    return current.def_events[(var_name, var_id)]
+                current = current.parent
+            return None
+
     def __init__(self):
         super().__init__()
-        self.id_to_def: dict[EventFile, dict[tuple[str, int, int, int], DefEvent]] = (
-            dict()
-        )
-        self.def_stack: dict[
-            EventFile, dict[int, dict[tuple[str, int], list[tuple[int, DefEvent]]]]
+        self.id_to_def: dict[EventFile, dict[tuple[str, int], DefEvent]] = dict()
+        self.id_to_def_thread: dict[
+            EventFile, dict[int, dict[tuple[str, int], DefEvent]]
         ] = dict()
+        self.def_stack: dict[EventFile, dict[int, DefUseFactory.DefScope]] = dict()
+
+    def reset(self, event_file: EventFile):
+        if event_file in self.id_to_def:
+            del self.id_to_def[event_file]
+        if event_file in self.id_to_def_thread:
+            del self.id_to_def_thread[event_file]
+        if event_file in self.def_stack:
+            del self.def_stack[event_file]
 
     def _find_def_event(
         self,
         event_file: EventFile,
+        thread_id: int,
         var_name: str,
         var_id: int,
-        scope_id: int,
-        thread_id: int,
     ) -> DefEvent:
-        # Strategy 1: Exact match in current thread and scope
-        exact_key = (var_name, var_id, scope_id, thread_id)
-        if exact_key in self.id_to_def.get(event_file, {}):
-            return self.id_to_def[event_file][exact_key]
-
-        # Strategy 2: Look up the scope stack in the current thread
-        thread_stack = self.def_stack.get(event_file, {}).get(thread_id, {})
-        var_key = (var_name, var_id)
-        if var_key in thread_stack and thread_stack[var_key]:
-            # Return the most recent (top of stack) DEF event
-            return thread_stack[var_key][-1][1]
-
-        # Strategy 3: Look for the same var_id in other threads (shared objects)
-        # This handles cross-thread variable sharing
-        for tid, thread_data in self.def_stack.get(event_file, {}).items():
-            if tid != thread_id and var_key in thread_data and thread_data[var_key]:
-                # Return the most recent DEF from another thread
-                return thread_data[var_key][-1][1]
-
-        return None
+        # Strategy 1: Check in scope stack (from innermost to outermost)
+        def_event = None
+        if event_file in self.def_stack and thread_id in self.def_stack[event_file]:
+            def_event = self.def_stack[event_file][thread_id].event(var_name, var_id)
+
+        # Strategy 2: Look up in the thread-specific DEF stack
+        if def_event is None:
+            if (
+                event_file in self.id_to_def_thread
+                and thread_id in self.id_to_def_thread[event_file]
+            ):
+                def_event = self.id_to_def_thread[event_file][thread_id].get(
+                    (var_name, var_id), None
+                )
+
+        # Strategy 3: Look up in the global DEF stack (other threads)
+        if def_event is None:
+            if event_file in self.id_to_def:
+                def_event = self.id_to_def[event_file].get((var_name, var_id), None)
+
+        return def_event
 
     def get_analysis(
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
         thread_id = event.thread_id
-        scope_id = scope.id if scope else 0
 
         if event.event_type == EventType.DEF:
-            var_key = (event.var, event.var_id)
-            full_key = (event.var, event.var_id, scope_id, thread_id)
-
-            with self._lock:
-                # Initialize structures if needed
-                if event_file not in self.id_to_def:
-                    self.id_to_def[event_file] = dict()
-                if event_file not in self.def_stack:
-                    self.def_stack[event_file] = dict()
-                if thread_id not in self.def_stack[event_file]:
-                    self.def_stack[event_file][thread_id] = dict()
-                if var_key not in self.def_stack[event_file][thread_id]:
-                    self.def_stack[event_file][thread_id][var_key] = []
-
-                # Store the DEF event
-                self.id_to_def[event_file][full_key] = event
-
-                # Add to stack for this thread
-                self.def_stack[event_file][thread_id][var_key].append((scope_id, event))
+            key = (event.var, event.var_id)
+
+            # Initialize structures if needed
+            if event_file not in self.id_to_def:
+                self.id_to_def[event_file] = dict()
+            if event_file not in self.id_to_def_thread:
+                self.id_to_def_thread[event_file] = dict()
+            if thread_id not in self.id_to_def_thread[event_file]:
+                self.id_to_def_thread[event_file][thread_id] = dict()
+            if event_file not in self.def_stack:
+                self.def_stack[event_file] = dict()
+            if thread_id not in self.def_stack[event_file]:
+                self.def_stack[event_file][thread_id] = DefUseFactory.DefScope()
+
+            # Store the DEF event
+            self.id_to_def[event_file][key] = event
+            self.id_to_def_thread[event_file][thread_id][key] = event
+            self.def_stack[event_file][thread_id].add(event.var, event.var_id, event)
 
         elif event.event_type == EventType.USE:
-            with self._lock:
-                def_event = self._find_def_event(
-                    event_file, event.var, event.var_id, scope_id, thread_id
-                )
+            def_event = self._find_def_event(
+                event_file, thread_id, event.var, event.var_id
+            )
 
             if def_event:
                 key = (
@@ -258,7 +284,24 @@ def get_analysis(
                     if key not in self.objects:
                         self.objects[key] = DefUse(def_event, event)
                 return [self.objects[key]]
-        return None
+        elif event.event_type == EventType.FUNCTION_ENTER:
+            if event_file not in self.def_stack:
+                self.def_stack[event_file] = dict()
+            if thread_id not in self.def_stack[event_file]:
+                self.def_stack[event_file][thread_id] = DefUseFactory.DefScope()
+            else:
+                self.def_stack[event_file][thread_id] = self.def_stack[event_file][
+                    thread_id
+                ].enter()
+        elif (
+            event.event_type == EventType.FUNCTION_EXIT
+            or event.event_type == EventType.FUNCTION_ERROR
+        ):
+            if event_file in self.def_stack and thread_id in self.def_stack[event_file]:
+                self.def_stack[event_file][thread_id] = self.def_stack[event_file][
+                    thread_id
+                ].exit()
+        return []
 
 
 class ConditionFactory(AnalysisFactory):
@@ -359,7 +402,7 @@ def get_analysis(
                                         )
                                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class VariableFactory(ComparisonFactory):
@@ -386,7 +429,7 @@ def get_analysis(
                         self.objects[key] = VariablePredicate(event, comp)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ReturnFactory(ComparisonFactory):
@@ -456,7 +499,7 @@ def get_analysis(
                                 )
                         objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ConstantCompFactory(AnalysisFactory):
@@ -483,7 +526,7 @@ def get_analysis(
                         self.objects[key] = self.class_(event)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class NoneFactory(ConstantCompFactory):
@@ -521,7 +564,7 @@ def get_analysis(
                     # noinspection PyArgumentList
                     self.objects[key] = self.class_(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class IsAsciiFactory(PredicateFunctionFactory):
@@ -572,7 +615,7 @@ def get_analysis(
                             Length(event, Length.evaluate_length_more)
                         )
             return self.objects[key][:]
-        return None
+        return []
 
 
 class FunctionErrorFactory(AnalysisFactory):
@@ -584,11 +627,9 @@ def get_analysis(
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
         if event.event_type == EventType.FUNCTION_ENTER:
-            with self._lock:
-                self.function_mapping[event.function_id] = event.line
+            self.function_mapping[event.function_id] = event.line
         if event.event_type in (EventType.FUNCTION_ERROR, EventType.FUNCTION_EXIT):
-            with self._lock:
-                line = self.function_mapping.get(event.function_id, event.line)
+            line = self.function_mapping.get(event.function_id, event.line)
             key = (
                 FunctionErrorPredicate.analysis_type(),
                 event.file,
@@ -601,7 +642,7 @@ def get_analysis(
                         event.file, line, event.function
                     )
             return [self.objects[key]]
-        return None
+        return []
 
 
 analysis_factory_mapping = {

src/sflkit/model/scope.py

@@ -51,23 +51,31 @@ def exit(self):
         else:
             return self
 
+    def __contains__(self, var: str) -> bool:
+        current = self
+        while current is not None:
+            if var in current.variables:
+                return True
+            current = current.parent
+        return False
+
     def value(self, var: str) -> Var:
-        if var in self.variables:
-            return self.variables[var].value
-        elif self.parent is not None:
-            return self.parent.value(var)
-        else:
-            return None
+        current = self
+        while current is not None:
+            if var in current.variables:
+                return current.variables[var].value
+            current = current.parent
+        return None
 
     def add(self, var, value, type_, id_: int = None):
         self.variables[var] = Var(var, value, type_, id_)
 
     def get_all_vars_dict(self):
-        if self.parent is not None:
-            variables = self.parent.get_all_vars_dict()
-        else:
-            variables = dict()
-        variables.update(self.variables)
+        current = self
+        variables = dict()
+        while current is not None:
+            variables = {**current.variables, **variables}
+            current = current.parent
         return variables
 
     def get_all_vars(self) -> List[Var]:

tests/test_scope.py

@@ -18,3 +18,26 @@ def test_var_eq(self):
     def test_scope_without_parent(self):
         scope = Scope()
         self.assertIs(scope, scope.exit())
+
+    def test_scope_with_parent(self):
+        parent_scope = Scope()
+        child_scope = parent_scope.enter()
+        self.assertIs(parent_scope, child_scope.exit())
+
+    def test_scope_contains(self):
+        scope = Scope()
+        scope.variables["x"] = Var("x", 10, int)
+        self.assertIn("x", scope)
+        self.assertNotIn("y", scope)
+
+    def test_scope_all_vars(self):
+        parent_scope = Scope()
+        parent_scope.variables["x"] = Var("x", 10, int)
+        child_scope = parent_scope.enter()
+        child_scope.variables["y"] = Var("y", 20, int)
+
+        all_vars = child_scope.get_all_vars_dict()
+        self.assertIn("x", all_vars)
+        self.assertIn("y", all_vars)
+        self.assertEqual(all_vars["x"].value, 10)
+        self.assertEqual(all_vars["y"].value, 20)