vorto 0.12.0

A Vim-flavored modal terminal editor with batteries included: tree-sitter, LSP, fuzzy pickers, vim-surround, multi-cursor, and optional Copilot.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Indents query handling.
//!
//! Drives the auto-indent behavior on `<newline>` / `o` / `O` and the
//! tree-sitter half of the indent-guide active-scope detection. Both
//! paths revolve around the `@indent.begin` capture from the
//! language's `indents.scm`.

use anyhow::Result;
use tree_sitter::{Language, Point, Query, QueryCursor, StreamingIterator, Tree};

/// Compiled `indents.scm` query for one language.
pub struct IndentQuery {
    query: Query,
    capture_names: Vec<String>,
}

impl IndentQuery {
    pub(super) fn compile(language: &Language, src: &str) -> Result<Self> {
        let query = Query::new(language, src)?;
        let capture_names = query
            .capture_names()
            .iter()
            .map(|s| s.to_string())
            .collect();
        Ok(Self {
            query,
            capture_names,
        })
    }

    /// True when the indents query has an `@indent.begin` capture
    /// whose node *opens* on `row`. Used by auto-indent on newline /
    /// `o` / `O`.
    ///
    /// Two shapes are accepted:
    /// - `start_row == row && end_row > row`: the node already has a
    ///   body that wraps the following lines (e.g. `def f():\n    x`).
    /// - `start_row == row && end_row == row` with an empty `body`
    ///   child: the node is mid-construction — the user just typed
    ///   `def f():` and hasn't filled in the body yet, so tree-sitter
    ///   reports a zero-width body block on the same row. Without
    ///   this branch Python auto-indent never fires while typing,
    ///   only after-the-fact when there's already body content below.
    pub(super) fn begins_at(&self, source: &str, tree: &Tree, row: usize) -> bool {
        let mut cursor = QueryCursor::new();
        cursor.set_point_range(
            Point { row, column: 0 }..Point {
                row: row.saturating_add(1),
                column: 0,
            },
        );
        let mut matches = cursor.matches(&self.query, tree.root_node(), source.as_bytes());
        while let Some(m) = matches.next() {
            for cap in m.captures {
                let name = self
                    .capture_names
                    .get(cap.index as usize)
                    .map(String::as_str)
                    .unwrap_or("");
                if name != "indent.begin" {
                    continue;
                }
                let node = cap.node;
                let start_row = node.start_position().row;
                let end_row = node.end_position().row;
                if start_row != row {
                    continue;
                }
                if end_row > row {
                    return true;
                }
                // Same-row span: distinguish an incomplete header
                // (empty body, user about to type it) from a true
                // one-liner (`if x: y` — body has content, no
                // auto-indent wanted).
                if let Some(body) = node.child_by_field_name("body")
                    && body.start_byte() == body.end_byte()
                {
                    return true;
                }
            }
        }
        false
    }

    /// Indent scopes intersecting `[start_row, end_row]`. Returns
    /// `(scope_start_row, scope_end_row)` inclusive on both ends.
    /// Same-row scopes are dropped — they contribute no body rows to
    /// draw a guide on. The caller is responsible for sorting / merging
    /// with injection scopes.
    pub(super) fn scopes_in_rows(
        &self,
        source: &str,
        tree: &Tree,
        start_row: usize,
        end_row: usize,
    ) -> Vec<(usize, usize)> {
        let mut out = Vec::new();
        let mut cursor = QueryCursor::new();
        // A scope intersecting the visible window is kept even when it
        // opens above `start_row` and closes below `end_row` — its
        // captured node overlaps the range, so tree-sitter's range
        // filter retains it, matching the explicit intersection check
        // below.
        cursor.set_point_range(
            Point {
                row: start_row,
                column: 0,
            }..Point {
                row: end_row.saturating_add(1),
                column: 0,
            },
        );
        let mut matches = cursor.matches(&self.query, tree.root_node(), source.as_bytes());
        while let Some(m) = matches.next() {
            for cap in m.captures {
                let name = self
                    .capture_names
                    .get(cap.index as usize)
                    .map(String::as_str)
                    .unwrap_or("");
                if name != "indent.begin" {
                    continue;
                }
                let node = cap.node;
                let s = node.start_position().row;
                let e = node.end_position().row;
                if e <= s {
                    continue;
                }
                if e < start_row || s > end_row {
                    continue;
                }
                out.push((s, e));
            }
        }
        out
    }
}