From e034f304553d2af2e39cb6439e7270fc1eae3b07 Mon Sep 17 00:00:00 2001
From: Shadowfacts <me@shadowfacts.net>
Date: Thu, 31 Oct 2024 11:35:43 -0400
Subject: [PATCH] Self doesn't need to be mutable when visting rule inputs

---
 crates/graph/src/lib.rs | 48 ++++++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/crates/graph/src/lib.rs b/crates/graph/src/lib.rs
index 78fc57d..28e5cfe 100644
--- a/crates/graph/src/lib.rs
+++ b/crates/graph/src/lib.rs
@@ -408,7 +408,7 @@ pub struct ErasedNode<Synch: Synchronicity> {
     any: Box<dyn Any>,
     is_valid: Box<dyn Fn(&Box<dyn Any>) -> bool>,
     invalidate: Box<dyn Fn(&mut Box<dyn Any>) -> ()>,
-    visit_inputs: Box<dyn Fn(&mut Box<dyn Any>, &mut dyn FnMut(NodeIndex<u32>) -> ()) -> ()>,
+    visit_inputs: Box<dyn Fn(&Box<dyn Any>, &mut dyn FnMut(NodeIndex<u32>) -> ()) -> ()>,
     update: Synch::UpdateFn,
 }
 
@@ -428,7 +428,7 @@ impl<S: Synchronicity> ErasedNode<S> {
                 x.invalidate();
             }),
             visit_inputs: Box::new(|any, visitor| {
-                let x = any.downcast_mut::<Box<dyn Node<V, S>>>().unwrap();
+                let x = any.downcast_ref::<Box<dyn Node<V, S>>>().unwrap();
                 x.visit_inputs(visitor);
             }),
             update: S::make_update_fn::<V>(),
@@ -447,15 +447,15 @@ impl<S: Synchronicity> ErasedNode<S> {
     fn invalidate(&mut self) {
         (self.invalidate)(&mut self.any);
     }
-    fn visit_inputs(&mut self, f: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
-        (self.visit_inputs)(&mut self.any, f);
+    fn visit_inputs(&self, f: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
+        (self.visit_inputs)(&self.any, f);
     }
 }
 
 trait Node<Value: 'static, Synch: Synchronicity> {
     fn is_valid(&self) -> bool;
     fn invalidate(&mut self);
-    fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ());
+    fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ());
     fn update(&mut self) -> Synch::UpdateResult<'_>;
     fn value_rc(&self) -> Rc<RefCell<Option<Value>>>;
 }
@@ -481,7 +481,7 @@ impl<V: Clone + 'static, S: Synchronicity> Node<V, S> for ConstNode<V, S> {
 
     fn invalidate(&mut self) {}
 
-    fn visit_inputs(&mut self, _visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {}
+    fn visit_inputs(&self, _visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {}
 
     fn update(&mut self) -> <S as Synchronicity>::UpdateResult<'_> {
         unreachable!()
@@ -519,10 +519,10 @@ impl<R: Rule, S: Synchronicity> Node<R::Output, S> for RuleNode<R, R::Output, S>
         self.valid = false;
     }
 
-    fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
+    fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
         struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ());
         impl<'a> InputVisitor for InputIndexVisitor<'a> {
-            fn visit<T>(&mut self, input: &mut Input<T>) {
+            fn visit<T>(&mut self, input: &Input<T>) {
                 self.0(input.node_idx);
             }
         }
@@ -569,10 +569,10 @@ where
         self.valid = false;
     }
 
-    fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
+    fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
         struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ());
         impl<'a> InputVisitor for InputIndexVisitor<'a> {
-            fn visit<T>(&mut self, input: &mut Input<T>) {
+            fn visit<T>(&mut self, input: &Input<T>) {
                 self.0(input.node_idx);
             }
         }
@@ -599,7 +599,7 @@ impl<R: AsyncRule> AsyncRuleNode<R, R::Output> {
 pub trait Rule: 'static {
     type Output;
 
-    fn visit_inputs(&mut self, visitor: &mut impl InputVisitor);
+    fn visit_inputs(&self, visitor: &mut impl InputVisitor);
 
     fn evaluate(&mut self) -> Self::Output;
 }
@@ -607,13 +607,13 @@ pub trait Rule: 'static {
 pub trait AsyncRule: 'static {
     type Output: 'static;
 
-    fn visit_inputs(&mut self, visitor: &mut impl InputVisitor);
+    fn visit_inputs(&self, visitor: &mut impl InputVisitor);
 
     async fn evaluate(&mut self) -> Self::Output;
 }
 
 pub trait InputVisitor {
-    fn visit<T>(&mut self, input: &mut Input<T>);
+    fn visit<T>(&mut self, input: &Input<T>);
 }
 
 #[cfg(test)]
@@ -630,7 +630,7 @@ mod tests {
     struct ConstantRule(i32);
     impl Rule for ConstantRule {
         type Output = i32;
-        fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {}
+        fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
         fn evaluate(&mut self) -> i32 {
             self.0
         }
@@ -656,8 +656,8 @@ mod tests {
     struct Double(Input<i32>);
     impl Rule for Double {
         type Output = i32;
-        fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) {
-            visitor.visit(&mut self.0);
+        fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
+            visitor.visit(&self.0);
         }
         fn evaluate(&mut self) -> i32 {
             self.0.value() * 2
@@ -683,7 +683,7 @@ mod tests {
     struct Inc(i32);
     impl Rule for Inc {
         type Output = i32;
-        fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {}
+        fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
         fn evaluate(&mut self) -> i32 {
             self.0 += 1;
             return self.0;
@@ -711,9 +711,9 @@ mod tests {
     struct Add(Input<i32>, Input<i32>);
     impl Rule for Add {
         type Output = i32;
-        fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) {
-            visitor.visit(&mut self.0);
-            visitor.visit(&mut self.1);
+        fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
+            visitor.visit(&self.0);
+            visitor.visit(&self.1);
         }
         fn evaluate(&mut self) -> i32 {
             self.0.value() + self.1.value()
@@ -759,9 +759,9 @@ mod tests {
     struct DeferredInput(Rc<RefCell<Option<Input<i32>>>>);
     impl Rule for DeferredInput {
         type Output = i32;
-        fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) {
-            let mut borrowed = self.0.borrow_mut();
-            let input = borrowed.as_mut().unwrap();
+        fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
+            let borrowed = self.0.borrow();
+            let input = borrowed.as_ref().unwrap();
             visitor.visit(input);
         }
         fn evaluate(&mut self) -> i32 {
@@ -830,7 +830,7 @@ mod tests {
         struct AsyncConst(i32);
         impl AsyncRule for AsyncConst {
             type Output = i32;
-            fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {}
+            fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
             async fn evaluate(&mut self) -> i32 {
                 self.0
             }