refactor(resolver): change Rule to a closed enum

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

1 files changed, 18 insertions, 26 deletions

diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
index 6c41e62..f5f66df 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
@@ -1,11 +1,11 @@
 //! ref: composer/src/Composer/DependencyResolver/RuleWatchGraph.php
 
-use std::any::Any;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 use indexmap::IndexMap;
 
 use crate::dependency_resolver::Decisions;
-use crate::dependency_resolver::MultiConflictRule;
 use crate::dependency_resolver::Rule;
 use crate::dependency_resolver::RuleWatchChain;
 use crate::dependency_resolver::RuleWatchNode;
@@ -22,17 +22,12 @@ impl RuleWatchGraph {
         }
     }
 
-    pub fn insert(&mut self, node: std::rc::Rc<std::cell::RefCell<RuleWatchNode>>) {
-        if node.borrow().get_rule().is_assertion() {
+    pub fn insert(&mut self, node: Rc<RefCell<RuleWatchNode>>) {
+        if node.borrow().get_rule().borrow().is_assertion() {
             return;
         }
 
-        let is_multi_conflict = node
-            .borrow()
-            .get_rule()
-            .as_any()
-            .downcast_ref::<MultiConflictRule>()
-            .is_some();
+        let is_multi_conflict = node.borrow().get_rule().borrow().is_multi_conflict_rule();
 
         if !is_multi_conflict {
             let watch1 = node.borrow().watch1;
@@ -47,7 +42,7 @@ impl RuleWatchGraph {
                     .unshift(node.clone());
             }
         } else {
-            let literals: Vec<i64> = node.borrow().get_rule().get_literals().clone();
+            let literals: Vec<i64> = node.borrow().get_rule().borrow().get_literals();
             for literal in literals {
                 if !self.watch_chains.contains_key(&literal) {
                     self.watch_chains.insert(literal, RuleWatchChain::new());
@@ -65,7 +60,7 @@ impl RuleWatchGraph {
         decided_literal: i64,
         level: i64,
         decisions: &mut Decisions,
-    ) -> Option<Box<dyn Rule>> {
+    ) -> Option<Rc<RefCell<Rule>>> {
         let literal = -decided_literal;
 
         if !self.watch_chains.contains_key(&literal) {
@@ -75,17 +70,14 @@ impl RuleWatchGraph {
         self.watch_chains.get_mut(&literal).unwrap().rewind();
         while self.watch_chains.get(&literal).unwrap().valid() {
             let node = self.watch_chains.get(&literal).unwrap().current().clone();
-            let is_multi_conflict = node
-                .borrow()
-                .get_rule()
-                .as_any()
-                .downcast_ref::<MultiConflictRule>()
-                .is_some();
+            let is_multi_conflict = node.borrow().get_rule().borrow().is_multi_conflict_rule();
             if !is_multi_conflict {
                 let other_watch = node.borrow().get_other_watch(literal);
 
-                if !node.borrow().get_rule().is_disabled() && !decisions.satisfy(other_watch) {
-                    let rule_literals: Vec<i64> = node.borrow().get_rule().get_literals().clone();
+                if !node.borrow().get_rule().borrow().is_disabled()
+                    && !decisions.satisfy(other_watch)
+                {
+                    let rule_literals: Vec<i64> = node.borrow().get_rule().borrow().get_literals();
 
                     let alternative_literals: Vec<i64> = rule_literals
                         .into_iter()
@@ -103,20 +95,20 @@ impl RuleWatchGraph {
                     }
 
                     if decisions.conflict(other_watch) {
-                        return Some(node.borrow().get_rule_boxed());
+                        return Some(node.borrow().get_rule());
                     }
 
-                    decisions.decide(other_watch, level, node.borrow().get_rule_boxed());
+                    decisions.decide(other_watch, level, node.borrow().get_rule());
                 }
             } else {
-                let literals: Vec<i64> = node.borrow().get_rule().get_literals().clone();
+                let literals: Vec<i64> = node.borrow().get_rule().borrow().get_literals();
                 for other_literal in literals {
                     if literal != other_literal && !decisions.satisfy(other_literal) {
                         if decisions.conflict(other_literal) {
-                            return Some(node.borrow().get_rule_boxed());
+                            return Some(node.borrow().get_rule());
                         }
 
-                        decisions.decide(other_literal, level, node.borrow().get_rule_boxed());
+                        decisions.decide(other_literal, level, node.borrow().get_rule());
                     }
                 }
             }
@@ -131,7 +123,7 @@ impl RuleWatchGraph {
         &mut self,
         from_literal: i64,
         to_literal: i64,
-        node: std::rc::Rc<std::cell::RefCell<RuleWatchNode>>,
+        node: Rc<RefCell<RuleWatchNode>>,
     ) {
         if !self.watch_chains.contains_key(&to_literal) {
             self.watch_chains.insert(to_literal, RuleWatchChain::new());