fix(core): fix detection integrity

Author: orenlab

CHANGELOG.md

@@ -12,13 +12,17 @@ workflows that reuse old baselines.
 ### Clone Detection Accuracy
 
 - **Commutative normalization**  
-  Canonicalized operand order for `+`, `*`, `|`, `&`, `^` when operands are free of side
-  effects, enabling safe detection of reordered expressions.
+  Canonicalized operand order for `+`, `*`, `|`, `&`, `^` only for provably safe constant
+  domains. Symbolic operands are no longer reordered.
 
 - **Local logical equivalence**  
   Normalized `not (x in y)` to `x not in y` and `not (x is y)` to `x is not y` without
   De Morgan transformations or broader boolean rewrites.
 
+- **Call-target preservation**  
+  Kept symbolic call targets during normalization to avoid conflating different APIs
+  (for example, `load_user(...)` vs `delete_user(...)`).
+
 ### CFG Precision
 
 - **Short‑circuit modeling**  
@@ -28,6 +32,19 @@ workflows that reuse old baselines.
   Linked `try/except` only to statements that may raise (calls, attribute access, indexing,
   `await`, `yield from`, `raise`) instead of blanket links.
 
+### Detection Integrity
+
+- **Internal CFG marker hardening**  
+  Switched CFG metadata markers to an internal namespace (`__CC_META__::...`) emitted as
+  synthetic AST names, preventing collisions with user string literals.
+
+- **Ordered control-flow semantics**  
+  Modeled `break`/`continue` as terminating loop transitions, added correct `for/while ... else`
+  semantics, preserved `match case` evaluation order, and preserved `except` handler order.
+
+- **Deterministic traversal order**  
+  Sorted Python file discovery to stabilize processing and report ordering across runs/platforms.
+
 ### Segment‑Level Detection
 
 - **Window fingerprints**  
@@ -36,6 +53,7 @@ workflows that reuse old baselines.
 - **Candidate generation**  
   Used an order‑insensitive signature for candidate grouping and a strict segment hash for
   final confirmation. Segment matches do not affect baseline or CI failure logic.
+
 - **Noise reduction (report‑only)**  
   Merged overlapping segment windows into a single span per function and suppressed
   boilerplate-only groups (attribute assignment wiring) with deterministic AST criteria.

codeclone.baseline.json

@@ -1,5 +1,12 @@
 {
-  "functions": [],
+  "functions": [
+    "056967a5e5569762522015b120810353dc84986a|20-49",
+    "2482e4ffa6c3c349be9626d4a95abbbb57193345|20-49",
+    "54b7b79d1ff3384fb96b3dd97944d7b67990b3f3|0-19",
+    "554bfacfa9bf1565bd2f5ea36e89b6efaee29c2d|0-19",
+    "b0070927d98fa8274982caef45107f4e6b4d6fef|0-19",
+    "c8e7da40a2dc106d1aa092044f88f01d9abae054|0-19"
+  ],
   "blocks": [],
   "python_version": "3.13",
   "baseline_version": "1.3.0",

codeclone/cfg.py

@@ -10,9 +10,11 @@
 
 import ast
 from collections.abc import Iterable
+from dataclasses import dataclass
 from typing import Protocol, cast
 
 from .cfg_model import CFG, Block
+from .meta_markers import CFG_META_PREFIX
 
 __all__ = ["CFG", "CFGBuilder"]
 
@@ -26,17 +28,28 @@ class _TryLike(Protocol):
     finalbody: list[ast.stmt]
 
 
+@dataclass(slots=True)
+class _LoopContext:
+    continue_target: Block
+    break_target: Block
+
+
+def _meta_expr(value: str) -> ast.Expr:
+    return ast.Expr(value=ast.Name(id=f"{CFG_META_PREFIX}{value}", ctx=ast.Load()))
+
+
 # =========================
 # CFG Builder
 # =========================
 
 
 class CFGBuilder:
-    __slots__ = ("cfg", "current")
+    __slots__ = ("_loop_stack", "cfg", "current")
 
     def __init__(self) -> None:
         self.cfg: CFG
         self.current: Block
+        self._loop_stack: list[_LoopContext] = []
 
     def build(
         self,
@@ -73,6 +86,12 @@ def _visit(self, stmt: ast.stmt) -> None:
                 self.current.is_terminated = True
                 self.current.add_successor(self.cfg.exit)
 
+            case ast.Break():
+                self._visit_break(stmt)
+
+            case ast.Continue():
+                self._visit_continue(stmt)
+
             case ast.If():
                 self._visit_if(stmt)
 
@@ -123,36 +142,61 @@ def _visit_if(self, stmt: ast.If) -> None:
     def _visit_while(self, stmt: ast.While) -> None:
         cond_block = self.cfg.create_block()
         body_block = self.cfg.create_block()
+        else_block = self.cfg.create_block() if stmt.orelse else None
         after_block = self.cfg.create_block()
 
         self.current.add_successor(cond_block)
 
         self.current = cond_block
-        self._emit_condition(stmt.test, body_block, after_block)
+        false_target = else_block if else_block is not None else after_block
+        self._emit_condition(stmt.test, body_block, false_target)
 
+        self._loop_stack.append(
+            _LoopContext(continue_target=cond_block, break_target=after_block)
+        )
         self.current = body_block
         self._visit_statements(stmt.body)
         if not self.current.is_terminated:
             self.current.add_successor(cond_block)
+        self._loop_stack.pop()
+
+        if else_block is not None:
+            self.current = else_block
+            self._visit_statements(stmt.orelse)
+            if not self.current.is_terminated:
+                self.current.add_successor(after_block)
 
         self.current = after_block
 
     def _visit_for(self, stmt: ast.For | ast.AsyncFor) -> None:
         iter_block = self.cfg.create_block()
         body_block = self.cfg.create_block()
+        else_block = self.cfg.create_block() if stmt.orelse else None
         after_block = self.cfg.create_block()
 
         self.current.add_successor(iter_block)
 
         self.current = iter_block
         self.current.statements.append(ast.Expr(value=stmt.iter))
         self.current.add_successor(body_block)
-        self.current.add_successor(after_block)
+        self.current.add_successor(
+            else_block if else_block is not None else after_block
+        )
 
+        self._loop_stack.append(
+            _LoopContext(continue_target=iter_block, break_target=after_block)
+        )
         self.current = body_block
         self._visit_statements(stmt.body)
         if not self.current.is_terminated:
             self.current.add_successor(iter_block)
+        self._loop_stack.pop()
+
+        if else_block is not None:
+            self.current = else_block
+            self._visit_statements(stmt.orelse)
+            if not self.current.is_terminated:
+                self.current.add_successor(after_block)
 
         self.current = after_block
 
@@ -188,19 +232,36 @@ def _visit_try(self, stmt: _TryLike) -> None:
         self.current.add_successor(try_entry)
         self.current = try_entry
 
-        handlers_blocks = [self.cfg.create_block() for _ in stmt.handlers]
+        handler_test_blocks = [self.cfg.create_block() for _ in stmt.handlers]
+        handler_body_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()
 
+        for idx, (handler, test_block, body_block) in enumerate(
+            zip(stmt.handlers, handler_test_blocks, handler_body_blocks, strict=True)
+        ):
+            test_block.statements.append(_meta_expr(f"TRY_HANDLER_INDEX:{idx}"))
+            if handler.type is not None:
+                type_repr = ast.dump(handler.type, annotate_fields=False)
+                test_block.statements.append(
+                    _meta_expr(f"TRY_HANDLER_TYPE:{type_repr}")
+                )
+            else:
+                test_block.statements.append(_meta_expr("TRY_HANDLER_TYPE:BARE"))
+            test_block.add_successor(body_block)
+            if idx + 1 < len(handler_test_blocks):
+                test_block.add_successor(handler_test_blocks[idx + 1])
+            else:
+                test_block.add_successor(final_block)
+
         # Process each statement in try body
         # Link only statements that can raise to exception handlers
         for stmt_node in stmt.body:
             if self.current.is_terminated:
                 break
 
-            if _stmt_can_raise(stmt_node):
-                for h_block in handlers_blocks:
-                    self.current.add_successor(h_block)
+            if _stmt_can_raise(stmt_node) and handler_test_blocks:
+                self.current.add_successor(handler_test_blocks[0])
 
             self._visit(stmt_node)
 
@@ -212,11 +273,8 @@ def _visit_try(self, stmt: _TryLike) -> None:
                 self.current.add_successor(final_block)
 
         # Process handlers
-        for handler, h_block in zip(stmt.handlers, handlers_blocks, strict=True):
-            self.current = h_block
-            if handler.type:
-                self.current.statements.append(ast.Expr(value=handler.type))
-
+        for handler, body_block in zip(stmt.handlers, handler_body_blocks, strict=True):
+            self.current = body_block
             self._visit_statements(handler.body)
             if not self.current.is_terminated:
                 self.current.add_successor(final_block)
@@ -236,25 +294,40 @@ def _visit_try(self, stmt: _TryLike) -> None:
     def _visit_match(self, stmt: ast.Match) -> None:
         self.current.statements.append(ast.Expr(value=stmt.subject))
 
-        subject_block = self.current
+        previous_test_block: Block | None = None
         after_block = self.cfg.create_block()
 
-        for case_ in stmt.cases:
-            case_block = self.cfg.create_block()
-            subject_block.add_successor(case_block)
+        for idx, case_ in enumerate(stmt.cases):
+            case_test_block = self.cfg.create_block()
+            case_body_block = self.cfg.create_block()
+
+            if previous_test_block is None:
+                self.current.add_successor(case_test_block)
+            else:
+                previous_test_block.add_successor(case_test_block)
 
-            self.current = case_block
+            case_test_block.statements.append(_meta_expr(f"MATCH_CASE_INDEX:{idx}"))
 
             # Record pattern structure
             pattern_repr = ast.dump(case_.pattern, annotate_fields=False)
-            self.current.statements.append(
-                ast.Expr(value=ast.Constant(value=f"PATTERN:{pattern_repr}"))
+            case_test_block.statements.append(
+                _meta_expr(f"MATCH_PATTERN:{pattern_repr}")
             )
+            if case_.guard is not None:
+                case_test_block.statements.append(ast.Expr(value=case_.guard))
+
+            case_test_block.add_successor(case_body_block)
 
+            self.current = case_body_block
             self._visit_statements(case_.body)
             if not self.current.is_terminated:
                 self.current.add_successor(after_block)
 
+            previous_test_block = case_test_block
+
+        if previous_test_block is not None:
+            previous_test_block.add_successor(after_block)
+
         self.current = after_block
 
     def _emit_condition(
@@ -300,6 +373,22 @@ def _emit_boolop(
 
         self.current = current
 
+    def _visit_break(self, stmt: ast.Break) -> None:
+        self.current.statements.append(stmt)
+        self.current.is_terminated = True
+        if self._loop_stack:
+            self.current.add_successor(self._loop_stack[-1].break_target)
+            return
+        self.current.add_successor(self.cfg.exit)
+
+    def _visit_continue(self, stmt: ast.Continue) -> None:
+        self.current.statements.append(stmt)
+        self.current.is_terminated = True
+        if self._loop_stack:
+            self.current.add_successor(self._loop_stack[-1].continue_target)
+            return
+        self.current.add_successor(self.cfg.exit)
+
 
 def _stmt_can_raise(stmt: ast.stmt) -> bool:
     if isinstance(stmt, ast.Raise):