sflkit 0.5.3__tar.gz → 0.5.4__tar.gz

{sflkit-0.5.3/src/sflkit.egg-info → sflkit-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.3
+Version: 0.5.4
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

{sflkit-0.5.3 → sflkit-0.5.4}/src/sflkit/__init__.py

@@ -6,7 +6,7 @@ from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
-__version__ = "0.5.3"
+__version__ = "0.5.4"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.3 → sflkit-0.5.4}/src/sflkit/analysis/factory.py

@@ -85,7 +85,7 @@ class LineFactory(AnalysisFactory):
                 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 @@ class BranchFactory(AnalysisFactory):
                 return [self.objects[key], self.objects[else_key]]
             return [self.objects[key]]
 
-        return None
+        return []
 
 
 class FunctionFactory(AnalysisFactory):
@@ -130,7 +130,7 @@ class FunctionFactory(AnalysisFactory):
                 if key not in self.objects:
                     self.objects[key] = Function(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class LoopFactory(AnalysisFactory):
@@ -170,27 +170,70 @@ class LoopFactory(AnalysisFactory):
             elif event.event_type == EventType.LOOP_END:
                 return self.objects[key][:]
             return list()
-        return None
+        return []
 
 
 class DefUseFactory(AnalysisFactory):
     def __init__(self):
         super().__init__()
         self.id_to_def: dict[EventFile, dict[tuple[str, int], DefEvent]] = dict()
+        self.def_stack: dict[EventFile, dict[int, dict[tuple[str, int], DefEvent]]] = (
+            dict()
+        )
 
     def reset(self, event_file: EventFile):
-        with self._lock:
-            self.id_to_def[event_file] = dict()
+        if event_file in self.id_to_def:
+            del self.id_to_def[event_file]
+        if event_file in self.def_stack:
+            del self.def_stack[event_file]
+
+    def _find_def_event(
+        self,
+        event_file: EventFile,
+        scope_id: int,
+        var_name: str,
+        var_id: int,
+    ) -> DefEvent:
+        # Strategy 1: Check in scope
+        def_event = None
+        if event_file in self.def_stack and scope_id in self.def_stack[event_file]:
+            def_event = self.def_stack[event_file][scope_id].get(
+                (var_name, var_id), None
+            )
+
+        # Strategy 2: 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:
-            with self._lock:
-                self.id_to_def[event_file][(event.var, event.var_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.def_stack:
+                self.def_stack[event_file] = dict()
+            if scope_id not in self.def_stack[event_file]:
+                self.def_stack[event_file][scope_id] = dict()
+
+            # Store the DEF event
+            self.id_to_def[event_file][key] = event
+            self.def_stack[event_file][scope_id][key] = event
+
         elif event.event_type == EventType.USE:
-            with self._lock:
-                def_event = self.id_to_def[event_file].get((event.var, event.var_id))
+            def_event = self._find_def_event(
+                event_file, scope_id, event.var, event.var_id
+            )
+
             if def_event:
                 key = (
                     DefUse.analysis_type(),
@@ -204,7 +247,7 @@ class DefUseFactory(AnalysisFactory):
                     if key not in self.objects:
                         self.objects[key] = DefUse(def_event, event)
                 return [self.objects[key]]
-        return None
+        return []
 
 
 class ConditionFactory(AnalysisFactory):
@@ -305,7 +348,7 @@ class ScalarPairFactory(ComparisonFactory):
                                         )
                                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class VariableFactory(ComparisonFactory):
@@ -332,7 +375,7 @@ class VariableFactory(ComparisonFactory):
                         self.objects[key] = VariablePredicate(event, comp)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ReturnFactory(ComparisonFactory):
@@ -402,7 +445,7 @@ class ReturnFactory(ComparisonFactory):
                                 )
                         objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ConstantCompFactory(AnalysisFactory):
@@ -429,7 +472,7 @@ class ConstantCompFactory(AnalysisFactory):
                         self.objects[key] = self.class_(event)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class NoneFactory(ConstantCompFactory):
@@ -467,7 +510,7 @@ class PredicateFunctionFactory(AnalysisFactory):
                     # noinspection PyArgumentList
                     self.objects[key] = self.class_(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class IsAsciiFactory(PredicateFunctionFactory):
@@ -518,7 +561,7 @@ class LengthFactory(AnalysisFactory):
                             Length(event, Length.evaluate_length_more)
                         )
             return self.objects[key][:]
-        return None
+        return []
 
 
 class FunctionErrorFactory(AnalysisFactory):
@@ -530,11 +573,9 @@ class FunctionErrorFactory(AnalysisFactory):
         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,
@@ -547,7 +588,7 @@ class FunctionErrorFactory(AnalysisFactory):
                         event.file, line, event.function
                     )
             return [self.objects[key]]
-        return None
+        return []
 
 
 analysis_factory_mapping = {

{sflkit-0.5.3 → sflkit-0.5.4}/src/sflkit/language/meta.py

@@ -1,5 +1,6 @@
 import random
 from abc import ABC
+from threading import Lock
 from typing import List, Type, Any
 
 from sflkitlib.events.event import Event
@@ -60,10 +61,12 @@ class Injection:
 class IDGenerator:
     def __init__(self):
         self.current_id = 0
+        self.lock = Lock()
 
     def get_next_id(self):
-        id_ = self.current_id
-        self.current_id += 1
+        with self.lock:
+            id_ = self.current_id
+            self.current_id += 1
         return id_
 
 

sflkit-0.5.4/src/sflkit/model/scope.py

@@ -0,0 +1,82 @@
+from threading import Lock
+from typing import List
+
+
+class Var(object):
+    def __init__(self, var, value, type_, id_: int = None):
+        self.var = var
+        self.value = value
+        self.type_ = type_
+        self.id = id_ if id_ is not None else hash(self)
+
+    def __hash__(self):
+        return hash(self.var)
+
+    def __eq__(self, other):
+        return isinstance(other, Var) and self.var == other.var
+
+
+class IDGenerator:
+    def __init__(self):
+        self.current_id = 0
+        self.lock = Lock()
+
+    def get_next_id(self):
+        with self.lock:
+            self.current_id += 1
+            return self.current_id
+
+
+class Scope(object):
+
+    SCOPE_ID = IDGenerator()
+
+    def __init__(self, parent=None):
+        self.parent = parent
+        self.variables = dict()
+        self.id = Scope.SCOPE_ID.get_next_id()
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        return isinstance(other, Scope) and self.id == other.id
+
+    def enter(self):
+        return Scope(parent=self)
+
+    def exit(self):
+        if self.parent is not None:
+            return self.parent
+        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:
+        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):
+        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]:
+        return list(self.get_all_vars_dict().values())

{sflkit-0.5.3 → sflkit-0.5.4/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.3
+Version: 0.5.4
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

sflkit-0.5.4/tests/test_scope.py

@@ -0,0 +1,43 @@
+import unittest
+
+from sflkit.model.scope import Var, Scope
+
+
+class TestScope(unittest.TestCase):
+    def test_var_eq(self):
+        var_1 = Var("x", 2, int)
+        var_2 = Var("y", 2, int)
+        var_3 = Var("x", "", str)
+        self.assertEqual(var_1, var_3)
+        self.assertNotEqual(var_1, var_2)
+        self.assertNotEqual(var_2, var_3)
+        self.assertEqual(hash(var_1), hash(var_3))
+        self.assertNotEqual(hash(var_1), hash(var_2))
+        self.assertNotEqual(hash(var_2), hash(var_3))
+
+    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)

sflkit-0.5.3/src/sflkit/model/scope.py

@@ -1,39 +0,0 @@
-from typing import List
-
-
-class Var(object):
-    def __init__(self, var, value, type_):
-        self.var = var
-        self.value = value
-        self.type_ = type_
-
-    def __hash__(self):
-        return hash(self.var)
-
-    def __eq__(self, other):
-        return isinstance(other, Var) and self.var == other.var
-
-
-class Scope(object):
-    def __init__(self, parent=None, variables: dict = None):
-        self.parent = parent
-        self.variables = dict() if variables is None else variables.copy()
-
-    def enter(self):
-        return Scope(parent=self, variables=self.variables)
-
-    def exit(self):
-        if self.parent is not None:
-            return self.parent
-        else:
-            return self
-
-    def value(self, var: str) -> Var:
-        if var in self.variables:
-            return self.variables[var].value
-
-    def add(self, var, value, type_):
-        self.variables[var] = Var(var, value, type_)
-
-    def get_all_vars(self) -> List[Var]:
-        return list(self.variables.values())

sflkit-0.5.3/tests/test_scope.py

@@ -1,20 +0,0 @@
-import unittest
-
-from sflkit.model.scope import Var, Scope
-
-
-class TestScope(unittest.TestCase):
-    def test_var_eq(self):
-        var_1 = Var("x", 2, int)
-        var_2 = Var("y", 2, int)
-        var_3 = Var("x", "", str)
-        self.assertEqual(var_1, var_3)
-        self.assertNotEqual(var_1, var_2)
-        self.assertNotEqual(var_2, var_3)
-        self.assertEqual(hash(var_1), hash(var_3))
-        self.assertNotEqual(hash(var_1), hash(var_2))
-        self.assertNotEqual(hash(var_2), hash(var_3))
-
-    def test_scope_without_parent(self):
-        scope = Scope()
-        self.assertIs(scope, scope.exit())