Clippy clean

2026-05-16 16:59:09 -04:00
parent ccc3984b01
commit 4347232b98
13 changed files with 134 additions and 99 deletions
--- a/lib/reactivity_parsing/examples/json_reactive_parser.rs
+++ b/lib/reactivity_parsing/examples/json_reactive_parser.rs
@@ -66,6 +66,13 @@ struct JsonParser {
    next_id: u64,
 }

+struct ReuseContext<'a, 'count> {
+    old_text: &'a str,
+    new_text: &'a str,
+    delta: &'a EditDelta,
+    reused: &'count mut usize,
+}
+
 struct Cursor<'a> {
    text: &'a str,
    offset: usize,
@@ -114,7 +121,7 @@ async fn main() {
    let parse_state = cell_in(&reactor, initial_snapshot);
    let last_delta = cell_in(&reactor, None::<EditDelta>);

-    let _parser_subscription = {
+    {
        let rope = rope.clone();
        let parser = Rc::clone(&parser);
        let parse_state = parse_state.clone();
@@ -283,15 +290,18 @@ impl JsonParser {
        let mut root_anchor = previous.root_anchor;
        root_anchor.map_through(delta);
        let mut reused = 0usize;
+        let mut reuse = ReuseContext {
+            old_text: &previous.text,
+            new_text: &text,
+            delta,
+            reused: &mut reused,
+        };
        let root = self.reuse_node(
            &parsed,
            Some(&previous.root),
            previous.root_anchor.byte,
            root_anchor.byte,
-            &previous.text,
-            &text,
-            delta,
-            &mut reused,
+            &mut reuse,
        );
        Ok(ParseSnapshot {
            text,
@@ -322,21 +332,18 @@ impl JsonParser {
        old: Option<&AstNode>,
        old_parent_start: usize,
        new_parent_start: usize,
-        old_text: &str,
-        new_text: &str,
-        delta: &EditDelta,
-        reused: &mut usize,
+        reuse: &mut ReuseContext<'_, '_>,
    ) -> AstNode {
        let parsed_local = localize(parsed.range, new_parent_start);
        if let Some(old) = old
            && old.kind == parsed.kind
-            && map_range(absolute_range(old, old_parent_start), delta) == parsed.range
-            && old_text.get(
+            && map_range(absolute_range(old, old_parent_start), reuse.delta) == parsed.range
+            && reuse.old_text.get(
                absolute_range(old, old_parent_start).start
                    ..absolute_range(old, old_parent_start).end,
-            ) == new_text.get(parsed.range.start..parsed.range.end)
+            ) == reuse.new_text.get(parsed.range.start..parsed.range.end)
        {
-            *reused += count_nodes(old);
+            *reuse.reused += count_nodes(old);
            return AstNode {
                id: old.id,
                kind: old.kind,
@@ -359,10 +366,7 @@ impl JsonParser {
                    previous_child,
                    next_old_parent_start,
                    parsed.range.start,
-                    old_text,
-                    new_text,
-                    delta,
-                    reused,
+                    reuse,
                )
            })
            .collect();
--- a/lib/reactivity_parsing/src/parse.rs
+++ b/lib/reactivity_parsing/src/parse.rs
@@ -38,6 +38,8 @@ pub struct ParseError {
    pub message: String,
 }

+pub type ParserResult<C, T, D> = Result<ParseResult<C, T, D>, ParseError>;
+
 impl ParseError {
    pub fn new(message: impl Into<String>) -> Self {
        Self {
@@ -66,7 +68,7 @@ pub trait IncrementalParser {
        cursor: RopeCursor,
        fragments: &[SyntaxFragment<Self::Checkpoint, Self::Tree, Self::Diagnostic>],
        invalidation: ParseInvalidation<Self::Checkpoint>,
-    ) -> Result<ParseResult<Self::Checkpoint, Self::Tree, Self::Diagnostic>, ParseError>;
+    ) -> ParserResult<Self::Checkpoint, Self::Tree, Self::Diagnostic>;
 }

 #[cfg(test)]
--- a/lib/reactivity_parsing/src/rope.rs
+++ b/lib/reactivity_parsing/src/rope.rs
@@ -1,6 +1,7 @@
 use std::cell::{Cell, RefCell};
 use std::cmp::min;
 use std::collections::BTreeSet;
+use std::fmt;
 use std::rc::Rc;

 use ruin_reactivity::{Event, Reactor, Source, event_in, source_in};
@@ -139,10 +140,6 @@ impl ReactiveRope {
        self.len_bytes() == 0
    }

-    pub fn to_string(&self) -> String {
-        self.slice(TextRange::new(0, self.len_bytes()))
-    }
-
    pub fn point_at(&self, offset: usize) -> TextPoint {
        self.inner.structure.observe();
        let offset = offset.min(self.len_bytes());
@@ -416,6 +413,12 @@ impl ReactiveRope {
    }
 }

+impl fmt::Display for ReactiveRope {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.slice(TextRange::new(0, self.len_bytes())))
+    }
+}
+
 impl RopeChunk {
    pub fn text(&self) -> &str {
        &self.text
--- a/lib/reactivity_parsing/src/tokentree.rs
+++ b/lib/reactivity_parsing/src/tokentree.rs
@@ -323,6 +323,13 @@ pub struct TokenTreeParser {
    next_id: u64,
 }

+struct ReuseContext<'a, 'count> {
+    old_text: &'a str,
+    new_text: &'a str,
+    delta: &'a EditDelta,
+    reused_nodes: &'count mut usize,
+}
+
 impl TokenTreeParser {
    pub fn new() -> Self {
        Self::default()
@@ -358,15 +365,18 @@ impl TokenTreeParser {
        let mut root_anchor = previous.root_anchor;
        root_anchor.map_through(delta);
        let mut reused_nodes = 0usize;
+        let mut reuse = ReuseContext {
+            old_text: &previous.text,
+            new_text: &text,
+            delta,
+            reused_nodes: &mut reused_nodes,
+        };
        let root = self.reuse_node(
            &raw.root,
            Some(&previous.root),
            previous.root_anchor.byte,
            root_anchor.byte,
-            &previous.text,
-            &text,
-            delta,
-            &mut reused_nodes,
+            &mut reuse,
        );
        let total_nodes = count_nodes(&root);

@@ -403,16 +413,20 @@ impl TokenTreeParser {
        old: Option<&TokenTreeNode>,
        old_parent_start: usize,
        new_parent_start: usize,
-        old_text: &str,
-        new_text: &str,
-        delta: &EditDelta,
-        reused_nodes: &mut usize,
+        reuse: &mut ReuseContext<'_, '_>,
    ) -> TokenTreeNode {
        let parsed_local = localize(parsed.range, new_parent_start);
-        if let Some(old) = old
-            .filter(|old| can_reuse_node(old, old_parent_start, parsed, old_text, new_text, delta))
-        {
-            *reused_nodes += count_nodes(old);
+        if let Some(old) = old.filter(|old| {
+            can_reuse_node(
+                old,
+                old_parent_start,
+                parsed,
+                reuse.old_text,
+                reuse.new_text,
+                reuse.delta,
+            )
+        }) {
+            *reuse.reused_nodes += count_nodes(old);
            return TokenTreeNode {
                id: old.id,
                local_range: parsed_local,
@@ -432,9 +446,8 @@ impl TokenTreeParser {
                        .children
                        .get(index)
                        .filter(|candidate| !used[index] && can_descend_into_node(candidate, child))
-                        .map(|candidate| {
+                        .inspect(|_| {
                            used[index] = true;
-                            candidate
                        })
                        .or_else(|| {
                            old.children.iter().enumerate().find_map(
@@ -455,10 +468,7 @@ impl TokenTreeParser {
                        candidate,
                        absolute_range(old, old_parent_start).start,
                        parsed.range.start,
-                        old_text,
-                        new_text,
-                        delta,
-                        reused_nodes,
+                        reuse,
                    )
                })
                .collect()
@@ -467,16 +477,7 @@ impl TokenTreeParser {
                .children
                .iter()
                .map(|child| {
-                    self.reuse_node(
-                        child,
-                        None,
-                        old_parent_start,
-                        parsed.range.start,
-                        old_text,
-                        new_text,
-                        delta,
-                        reused_nodes,
-                    )
+                    self.reuse_node(child, None, old_parent_start, parsed.range.start, reuse)
                })
                .collect()
        };
@@ -545,12 +546,12 @@ impl<'a> Cursor<'a> {
                break;
            }

-            if let Some(close) = terminator {
-                if self.peek_char() == Some(close) {
-                    self.bump_char();
-                    terminated = true;
-                    break;
-                }
+            if let Some(close) = terminator
+                && self.peek_char() == Some(close)
+            {
+                self.bump_char();
+                terminated = true;
+                break;
            }

            let Some(ch) = self.peek_char() else {
@@ -1376,7 +1377,7 @@ mod tests {
            .collect()
    }

-    fn find_list_child<'a>(node: &'a TokenTreeNode, delimiter: DelimiterKind) -> &'a TokenTreeNode {
+    fn find_list_child(node: &TokenTreeNode, delimiter: DelimiterKind) -> &TokenTreeNode {
        node.children
            .iter()
            .find(|child| {