sflkit 0.5.3__tar.gz → 0.5.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.3
+Version: 0.5.5
 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.5}/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.5"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.3 → sflkit-0.5.5}/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.5}/src/sflkit/analysis/spectra.py

@@ -722,7 +722,13 @@ class DefUse(Spectrum):
 
     @staticmethod
     def events():
-        return [EventType.DEF, EventType.USE]
+        return [
+            EventType.DEF,
+            EventType.USE,
+            EventType.FUNCTION_ENTER,
+            EventType.FUNCTION_EXIT,
+            EventType.FUNCTION_ERROR,
+        ]
 
     def get_suggestion(
         self, metric: Callable = None, base_dir: str = "", use_weight: bool = False

{sflkit-0.5.3 → sflkit-0.5.5}/src/sflkit/instrumentation/file_instrumentation.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import List, Optional
 
@@ -11,7 +12,11 @@ class FileInstrumentation(Instrumentation):
         super().__init__(visitor, mapping_path)
 
     def instrument(
-        self, src: str, dst: str, suffixes: List[str] = None, file: str = ""
+        self,
+        src: os.PathLike,
+        dst: os.PathLike,
+        suffixes: List[str] = None,
+        file: str = "",
     ):
         self.visitor.instrument(src, dst, file)
         self.events = EventMapping(

{sflkit-0.5.3 → sflkit-0.5.5}/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_
 
 
@@ -85,6 +88,7 @@ class MetaVisitor(ABC):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int = 0,
         **kwargs,
     ):
         self.event_id_generator = event_id_generator
@@ -95,6 +99,27 @@ class MetaVisitor(ABC):
         self.condition_extract = language.condition_extract
         self.event_count = 0
         self.file = None
+        self.order = order
+
+    def __lt__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order < other.order
+
+    def __gt__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order > other.order
+
+    def __le__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order <= other.order
+
+    def __ge__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order >= other.order
 
     def get_event_call(self, event: Event):
         pass
@@ -145,26 +170,30 @@ class CombinationVisitor(MetaVisitor):
             tmp_generator,
         )
         if test:
-            self.visitors = [
-                visitor(
-                    language,
-                    event_id_generator,
-                    function_id_generator,
-                    tmp_generator,
-                    ignore_inner=ignore_inner,
-                )
-                for visitor in visitors
-            ]
+            self.visitors = sorted(
+                [
+                    visitor(
+                        language,
+                        event_id_generator,
+                        function_id_generator,
+                        tmp_generator,
+                        ignore_inner=ignore_inner,
+                    )
+                    for visitor in visitors
+                ],
+            )
         else:
-            self.visitors = [
-                visitor(
-                    language,
-                    event_id_generator,
-                    function_id_generator,
-                    tmp_generator,
-                )
-                for visitor in visitors
-            ]
+            self.visitors = sorted(
+                [
+                    visitor(
+                        language,
+                        event_id_generator,
+                        function_id_generator,
+                        tmp_generator,
+                    )
+                    for visitor in visitors
+                ],
+            )
 
     def visit_start(self, *args) -> Injection:
         injections = Injection()

{sflkit-0.5.3 → sflkit-0.5.5}/src/sflkit/language/python/factory.py

@@ -56,10 +56,15 @@ class PythonEventFactory(MetaVisitor, NodeVisitor):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int = 0,
         **kwargs,
     ):
         super().__init__(
-            language, event_id_generator, function_id_generator, tmp_generator
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
         )
 
     def visit_start(self, *args) -> Injection:
@@ -291,7 +296,21 @@ class DefEventFactory(PythonEventFactory):
     def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> Injection:
         return self.visit_function(node)
 
-    def get_event(self, node: typing.Union[Assign, AnnAssign, AugAssign], var: str):
+    def get_event(
+        self,
+        node: typing.Union[
+            Assign,
+            AnnAssign,
+            AugAssign,
+            FunctionDef,
+            AsyncFunctionDef,
+            For,
+            AsyncFor,
+            With,
+            AsyncWith,
+        ],
+        var: str,
+    ):
         return DefEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), var
         )
@@ -369,18 +388,24 @@ class FunctionEventFactory(PythonEventFactory):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int,
         **kwargs,
     ):
         super().__init__(
-            language, event_id_generator, function_id_generator, tmp_generator, **kwargs
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
+            **kwargs,
         )
         self.function_stack = list()
 
     def get_function_id(self, node: AST) -> int:
         if node not in FunctionEventFactory.functions:
-            FunctionEventFactory.functions[
-                node
-            ] = self.function_id_generator.get_next_id()
+            FunctionEventFactory.functions[node] = (
+                self.function_id_generator.get_next_id()
+            )
         return FunctionEventFactory.functions[node]
 
     @staticmethod
@@ -403,6 +428,23 @@ class FunctionEventFactory(PythonEventFactory):
 
 
 class FunctionEnterEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_enter_event"
 
@@ -441,6 +483,23 @@ class FunctionEnterEventFactory(FunctionEventFactory):
 
 
 class FunctionExitEventFactor(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_exit_event"
 
@@ -521,6 +580,23 @@ class FunctionExitEventFactor(FunctionEventFactory):
 
 
 class FunctionErrorEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_error_event"
 
@@ -550,6 +626,24 @@ class LoopEventFactory(PythonEventFactory):
     loops: typing.Dict[AST, int] = dict()
     loop_id: int = 0
 
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        order: int,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
+            **kwargs,
+        )
+
     @staticmethod
     def get_loop_id(node: AST) -> int:
         if node not in LoopEventFactory.loops:
@@ -571,6 +665,23 @@ class LoopEventFactory(PythonEventFactory):
 
 
 class LoopBeginEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_begin_event"
 
@@ -587,6 +698,23 @@ class LoopBeginEventFactory(LoopEventFactory):
 
 
 class LoopHitEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_hit_event"
 
@@ -603,6 +731,23 @@ class LoopHitEventFactory(LoopEventFactory):
 
 
 class LoopEndEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_end_event"
 
@@ -717,6 +862,7 @@ class UseEventFactory(PythonEventFactory):
         return self._get_try_wrapper(event)
 
     def get_event(self, node: AST, use: str) -> UseEvent:
+        # noinspection PyUnresolvedReferences
         return UseEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), use
         )
@@ -894,6 +1040,23 @@ class LenEventFactory(DefEventFactory):
 
 
 class TestStartEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_test_start_event"
 
@@ -924,6 +1087,23 @@ class TestStartEventFactory(FunctionEventFactory):
 
 
 class TestEndEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_test_end_event"
 
@@ -991,6 +1171,7 @@ class TestLineEventFactory(LineEventFactory):
         return "add_test_line_event"
 
     def visit_line(self, node: AST) -> Injection:
+        # noinspection PyUnresolvedReferences
         line_event = TestLineEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id()
         )
@@ -1113,6 +1294,7 @@ class TestUseEventFactory(UseEventFactory):
         return "add_test_use_event"
 
     def get_event(self, node: AST, use: str) -> TestUseEvent:
+        # noinspection PyUnresolvedReferences
         return TestUseEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), use
         )

{sflkit-0.5.3 → sflkit-0.5.5}/src/sflkit/language/visitor.py

@@ -1,3 +1,4 @@
+import os
 from abc import abstractmethod, ABC
 
 from sflkit.language.meta import MetaVisitor
@@ -22,7 +23,7 @@ class ASTVisitor(ABC):
     def start_visit(self, ast):
         raise NotImplementedError()
 
-    def instrument(self, src: str, dst: str, file: str = ""):
+    def instrument(self, src: os.PathLike, dst: os.PathLike, file: str = ""):
         self.file = file
         with open(src, "r") as fp:
             source = fp.read()