codeclone 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codeclone/baseline.py

@@ -10,22 +10,24 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Set
 
 
 class Baseline:
-    def __init__(self, path: str):
+    def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.functions: Set[str] = set()
-        self.blocks: Set[str] = set()
+        self.functions: set[str] = set()
+        self.blocks: set[str] = set()
 
     def load(self) -> None:
         if not self.path.exists():
             return
 
-        data = json.loads(self.path.read_text("utf-8"))
-        self.functions = set(data.get("functions", []))
-        self.blocks = set(data.get("blocks", []))
+        try:
+            data = json.loads(self.path.read_text("utf-8"))
+            self.functions = set(data.get("functions", []))
+            self.blocks = set(data.get("blocks", []))
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Corrupted baseline file at {self.path}: {e}") from e
 
     def save(self) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -42,8 +44,10 @@ class Baseline:
         )
 
     @staticmethod
-    def from_groups(func_groups: dict, block_groups: dict) -> "Baseline":
-        bl = Baseline("")
+    def from_groups(
+        func_groups: dict, block_groups: dict, path: str | Path = ""
+    ) -> "Baseline":
+        bl = Baseline(path)
         bl.functions = set(func_groups.keys())
         bl.blocks = set(block_groups.keys())
         return bl

codeclone/cache.py

@@ -12,17 +12,21 @@ import json
 import os
 from dataclasses import asdict
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 
 class Cache:
-    def __init__(self, path: str):
+    def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.data: dict = {"files": {}}
+        self.data: dict[str, Any] = {"files": {}}
 
     def load(self) -> None:
         if self.path.exists():
-            self.data = json.loads(self.path.read_text("utf-8"))
+            try:
+                self.data = json.loads(self.path.read_text("utf-8"))
+            except json.JSONDecodeError:
+                # If cache is corrupted, start fresh
+                self.data = {"files": {}}
 
     def save(self) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -31,10 +35,12 @@ class Cache:
             "utf-8",
         )
 
-    def get_file_entry(self, filepath: str) -> Optional[dict]:
+    def get_file_entry(self, filepath: str) -> Optional[dict[str, Any]]:
         return self.data.get("files", {}).get(filepath)
 
-    def put_file_entry(self, filepath: str, stat_sig: dict, units, blocks) -> None:
+    def put_file_entry(
+        self, filepath: str, stat_sig: dict[str, Any], units: list, blocks: list
+    ) -> None:
         self.data.setdefault("files", {})[filepath] = {
             "stat": stat_sig,
             "units": [asdict(u) for u in units],

codeclone/cfg.py

@@ -107,6 +107,18 @@ class CFGBuilder:
             case ast.For():
                 self._visit_for(stmt)
 
+            case ast.AsyncFor():
+                self._visit_for(stmt)  # Structure is identical to For
+
+            case ast.Try() | ast.TryStar():
+                self._visit_try(stmt)
+
+            case ast.With() | ast.AsyncWith():
+                self._visit_with(stmt)
+
+            case ast.Match():
+                self._visit_match(stmt)
+
             case _:
                 self.current.statements.append(stmt)
 
@@ -153,7 +165,7 @@ class CFGBuilder:
 
         self.current = after_block
 
-    def _visit_for(self, stmt: ast.For) -> None:
+    def _visit_for(self, stmt: ast.For | ast.AsyncFor) -> None:
         iter_block = self.cfg.create_block()
         body_block = self.cfg.create_block()
         after_block = self.cfg.create_block()
@@ -171,3 +183,156 @@ class CFGBuilder:
             self.current.add_successor(iter_block)
 
         self.current = after_block
+
+    def _visit_with(self, stmt: ast.With | ast.AsyncWith) -> None:
+        # Treat WITH as linear flow (enter -> body -> exit), but preserve block structure
+        # We record the context manager expression in the current block
+        # Then we enter a new block for the body (to separate it structurally)
+        # Then we enter a new block for 'after' (exit)
+
+        # Why new block? Because 'with' implies a scope/context.
+        # It helps matching.
+
+        body_block = self.cfg.create_block()
+        after_block = self.cfg.create_block()
+
+        # Record the 'items' (context managers)
+        # We wrap them in Expr to treat them as statements for hashing
+        for item in stmt.items:
+            self.current.statements.append(ast.Expr(value=item.context_expr))
+
+        self.current.add_successor(body_block)
+
+        self.current = body_block
+        self._visit_statements(stmt.body)
+        if not self.current.is_terminated:
+            self.current.add_successor(after_block)
+
+        self.current = after_block
+
+    def _visit_try(self, stmt: ast.Try | ast.TryStar) -> None:
+        # Simplified Try CFG:
+        # Try Body -> [Handlers...] -> Finally/After
+        # Try Body -> Else -> Finally/After
+
+        try_block = self.cfg.create_block()
+        self.current.add_successor(try_block)
+
+        # We don't know WHERE in the try block exception happens, so we assume
+        # any point in try block *could* jump to handlers.
+        # But for structural hashing, we just process the body.
+        # Ideally, we should link the try_block (or its end) to handlers?
+        # A simple approximation:
+        # 1. Process body.
+        # 2. Link entry (or end of body) to handlers?
+        # Let's do: Entry -> BodyBlock.
+        # Entry -> HandlerBlocks (to represent potential jump).
+
+        # Actually, let's keep it linear but branched.
+        # Current -> TryBody
+        # Current -> Handlers (Abstractly representing the jump)
+
+        handlers_blocks = [self.cfg.create_block() for _ in stmt.handlers]
+        else_block = self.cfg.create_block() if stmt.orelse else None
+        final_block = self.cfg.create_block()  # This is finally or after
+
+        # Link current to TryBody
+        self.current = try_block
+        self._visit_statements(stmt.body)
+
+        # If try body finishes successfully:
+        if not self.current.is_terminated:
+            if else_block:
+                self.current.add_successor(else_block)
+            else:
+                self.current.add_successor(final_block)
+
+        # Handle Else
+        if else_block:
+            self.current = else_block
+            self._visit_statements(stmt.orelse)
+            if not self.current.is_terminated:
+                self.current.add_successor(final_block)
+
+        # Handle Handlers
+        # We assume control flow *could* jump from start of Try to any handler
+        # (Technically from inside try, but we model structural containment)
+        # To make fingerprints stable, we just need to ensure handlers are visited
+        # and linked.
+
+        # We link the *original* predecessor (before try) or the try_block start to handlers?
+        # Let's link the `try_block` (as a container concept) to handlers.
+        # But `try_block` was mutated by `_visit_statements`.
+        # Let's use the `try_block` (start of try) to link to handlers.
+        for h_block in handlers_blocks:
+            try_block.add_successor(h_block)
+
+        for handler, h_block in zip(stmt.handlers, handlers_blocks):
+            self.current = h_block
+            # Record exception type
+            if handler.type:
+                self.current.statements.append(ast.Expr(value=handler.type))
+            self._visit_statements(handler.body)
+            if not self.current.is_terminated:
+                self.current.add_successor(final_block)
+
+        # Finally logic:
+        # If there is a finally block, `final_block` IS the finally block.
+        # We visit it. Then we create a new `after_finally` block?
+        # Or `final_block` is the start of finally.
+
+        if stmt.finalbody:
+            self.current = final_block
+            self._visit_statements(stmt.finalbody)
+            # And then continue to next code?
+            # Yes, finally flows to next statement.
+            # Unless terminated.
+
+        # If no finally, `final_block` is just the merge point (after).
+        self.current = final_block
+
+    def _visit_match(self, stmt: ast.Match) -> None:
+        # Match subject -> Cases -> After
+
+        self.current.statements.append(ast.Expr(value=stmt.subject))
+
+        after_block = self.cfg.create_block()
+
+        for case_ in stmt.cases:
+            case_block = self.cfg.create_block()
+            self.current.add_successor(case_block)
+
+            # Save current context to restore for next case branching?
+            # No, 'current' is the match subject block. It branches to ALL cases.
+
+            # Visit Case
+            # We must set self.current to case_block for visiting body
+            # But we lose reference to 'match subject block' to link next case!
+            # So we need a variable `subject_block`.
+            pass
+
+        # Re-implementing loop correctly
+        subject_block = self.current
+
+        for case_ in stmt.cases:
+            case_block = self.cfg.create_block()
+            subject_block.add_successor(case_block)
+
+            self.current = case_block
+            # We could record the pattern here?
+            # patterns are complex AST nodes. For now, let's skip pattern structure hash
+            # and just hash the body. Or dump pattern as statement?
+            # Pattern is not a statement.
+            # Let's ignore pattern details for V1, or try to normalize it.
+            # If we ignore pattern, then `case []:` and `case {}:` look same.
+            # Ideally: `self.current.statements.append(case_.pattern)` but pattern is not stmt.
+            # We can wrap in Expr? `ast.Expr(value=case_.pattern)`?
+            # Pattern is NOT an Expr subclass in 3.10. It's `ast.pattern`.
+            # So we cannot append it to `statements` list which expects `ast.stmt`.
+            # We will ignore pattern structure for now (it's structural flow we care about).
+
+            self._visit_statements(case_.body)
+            if not self.current.is_terminated:
+                self.current.add_successor(after_block)
+
+        self.current = after_block