Bug fix in parent scope rules (#778)

**Summary:**
There is a bug in piranha core that prevents parent rules from being
match only. Parent scope is forcibly applying edits without checking
whether the rule is match only. This PR fixes that


**Test plan:**
I added a test that fails without the fix to illustrate the problem, as
well as an E2E test

Author: danieltrt

crates/core/src/models/edit.rs

@@ -139,17 +139,23 @@ impl SourceCodeUnit {
     //  we apply the rules in the order they are provided to each ancestor in the context
     for rule in &next_rules[PARENT] {
       for ancestor in &context() {
-        if let Some(edit) = self.get_edit(rule, rules_store, *ancestor, false) {
-          return Some(edit);
+        // Skip match-only rules - they should not create edits for parent scope
+        if !rule.rule().is_match_only_rule() {
+          if let Some(edit) = self.get_edit(rule, rules_store, *ancestor, false) {
+            return Some(edit);
+          }
         }
       }
     }
 
     // we apply the rules to each ancestor in the context in the order they are provided
     for ancestor in &context() {
       for rule in &next_rules[PARENT_ITERATIVE] {
-        if let Some(edit) = self.get_edit(rule, rules_store, *ancestor, false) {
-          return Some(edit);
+        // Skip match-only rules - they should not create edits for parent scope
+        if !rule.rule().is_match_only_rule() {
+          if let Some(edit) = self.get_edit(rule, rules_store, *ancestor, false) {
+            return Some(edit);
+          }
         }
       }
     }

crates/core/src/models/unit_tests/rule_test.rs

@@ -384,6 +384,67 @@ fn test_satisfies_filter_not_enclosing_node_negative() {
   );
 }
 
+/// Test that match-only parent rules do not create edits (regression test for bug fix)
+#[test]
+fn test_match_only_parent_rule_no_edit() {
+  // Create a match-only rule (no replace_node specified)
+  let _match_only_rule = piranha_rule! {
+    name = "match_only_parent",
+    query = "(
+      (binary_expression
+          left : (_)* @lhs
+          operator:\"&&\"
+          right: [(true) (parenthesized_expression (true))]
+      )
+  @binary_expression)"
+    // Note: no replace_node specified, making this a match-only rule
+  };
+  let match_only_rule = InstantiatedRule::new(&_match_only_rule, &HashMap::new());
+
+  // Verify it's actually a match-only rule
+  assert!(match_only_rule.rule().is_match_only_rule());
+
+  let source_code = "class A {
+          boolean f = something && true;
+        }";
+
+  let mut rule_store = RuleStore::default();
+  let args = PiranhaArgumentsBuilder::default()
+    .paths_to_codebase(vec![UNUSED_CODE_PATH.to_string()])
+    .language(PiranhaLanguage::from(JAVA))
+    .build();
+  let mut parser = args.language().parser();
+
+  let source_code_unit = SourceCodeUnit::new(
+    &mut parser,
+    source_code.to_string(),
+    &HashMap::new(),
+    PathBuf::new().as_path(),
+    &args,
+  );
+
+  // Range pointing to part of the binary expression that would trigger parent rule matching
+  let range = Range {
+    start_byte: 41_usize,
+    end_byte: 44_usize,
+    ..Default::default()
+  };
+
+  // Set up match-only rule as a parent rule
+  let next_rules = HashMap::from([
+    (String::from(PARENT), vec![match_only_rule.clone()]),
+    (String::from(PARENT_ITERATIVE), vec![match_only_rule]),
+  ]);
+
+  // Before the fix: this would return Some(edit) that deletes content
+  // After the fix: this should return None because match-only rules shouldn't create edits
+  let edit = source_code_unit.get_edit_for_ancestors(&range, &mut rule_store, &next_rules);
+  assert!(
+    edit.is_none(),
+    "Match-only parent rules should not create edits"
+  );
+}
+
 /// Tests whether comments are preserved when delete_comments is set to false
 #[test]
 fn test_rule_delete_comments() {

tests/test_piranha.py

@@ -378,3 +378,86 @@ def test_kotlin_boolean_simplification():
         }
         return true
         }"""
+
+
+def test_match_only_parent_rule_bug_fix():
+    """
+    Regression test for bug where match-only parent rules were incorrectly deleting code.
+    
+    Before the fix: match-only parent rules would create deletion edits
+    After the fix: match-only parent rules should only match without transforming code
+    """
+    code = """
+if (obj.isLocEnabled() || x > 0) {
+    // do something
+    x = obj.isLocEnabled();
+    if (other_check) { }
+} else {
+    // do something else!
+}
+"""
+
+    # Seed rule that replaces method calls with true
+    seed_rule = Rule(
+        name="replace_method",
+        query="cs :[x].isLocEnabled()",
+        replace_node="*",
+        replace="true",
+        is_seed_rule=True
+    )
+
+    # Match-only parent rule - should NOT delete the assignment
+    # This rule has no replace_node, making it match-only
+    match_only_parent_rule = Rule(
+        name="find_assignment_parent",
+        query="cs :[x] = true;"
+        # Note: no replace_node specified = match-only rule
+    )
+
+    # This rule should only be triggered after the match-only parent rule
+    logic_triggered_only_after_match_only_parent_rule = Rule(
+        name="logic_triggered_only_after_match_only_parent_rule",
+        query='cs if (other_check) { }',
+        replace_node="*",
+    )
+
+
+    # Parent edge: after replacing method call, look for assignments in parent scope
+    parent_edge = OutgoingEdges(
+        "replace_method",
+        ["find_assignment_parent"],
+        "Parent"
+    )
+    file_edge = OutgoingEdges(
+        "find_assignment_parent",
+        ["logic_triggered_only_after_match_only_parent_rule"],
+        "File"
+    )
+
+    rule_graph = RuleGraph(
+        rules=[seed_rule, match_only_parent_rule, logic_triggered_only_after_match_only_parent_rule], 
+        edges=[parent_edge, file_edge]
+    )
+
+    args = PiranhaArguments(
+        code_snippet=code,
+        language="java",
+        rule_graph=rule_graph
+    )
+
+    output_summaries = execute_piranha(args)
+    assert len(output_summaries) == 1
+    
+    result_code = output_summaries[0].content
+    
+    # The seed rule should replace isLocEnabled() with true
+    assert "obj.isLocEnabled()" not in result_code
+    assert "x = true;" in result_code
+    
+    # CRITICAL: The match-only parent rule should NOT delete the assignment
+    # Before the bug fix, this line would be deleted
+    # After the bug fix, this line should remain
+    assert "x = true;" in result_code, "Match-only parent rule incorrectly deleted the assignment"
+    
+    # The if condition should also be deleted
+    assert "if (other_check) { }" not in result_code