arity 0.15.0

A language server, formatter, and linter for R
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

use super::*;
use crate::syntax::SyntaxToken;

/// The "smart selection" chains (`textDocument/selectionRange`) for each cursor
/// `position`: from the token under the cursor outward through its enclosing CST
/// nodes to the whole file. A pure single-file CST walk with no semantic model —
/// never consults the workspace.
///
/// The response is index-aligned with `positions`: one [`SelectionRange`] chain
/// per position, its innermost range at the top level and each `parent` pointing
/// one step further out.
pub fn compute_selection_ranges(
    text: &str,
    positions: &[Position],
    encoding: PositionEncoding,
) -> Vec<SelectionRange> {
    let root = parse(text).cst;
    let line_index = LineIndex::new(text);
    positions
        .iter()
        .map(|&position| {
            let offset = TextSize::new(
                line_index
                    .position_to_byte(position, encoding)
                    .min(text.len()) as u32,
            );
            selection_range_at(&root, &line_index, offset, encoding)
        })
        .collect()
}

/// Build one selection-range chain for `offset`: seed with the token under the
/// cursor (unless it is pure layout trivia) and expand through its ancestors,
/// collapsing equal-range wrapper nodes so no level equals its parent.
fn selection_range_at(
    root: &SyntaxNode,
    line_index: &LineIndex,
    offset: TextSize,
    encoding: PositionEncoding,
) -> SelectionRange {
    let mut ranges: Vec<TextRange> = Vec::new();

    if let Some(token) = token_at(root, offset) {
        // A cursor sitting on whitespace/newline expands from the enclosing node
        // rather than selecting the (invisible) layout token itself. Comments are
        // real content, so they stay as the innermost selection.
        if !matches!(token.kind(), SyntaxKind::WHITESPACE | SyntaxKind::NEWLINE) {
            ranges.push(token.text_range());
        }
        for ancestor in token.parent_ancestors() {
            let range = ancestor.text_range();
            if ranges.last() != Some(&range) {
                ranges.push(range);
            }
        }
    }

    // Empty document, or a position with no token (e.g. past the last line): fall
    // back to a single whole-file range so every position still yields a chain.
    if ranges.is_empty() {
        ranges.push(root.text_range());
    }

    // Fold outermost -> innermost so each level's `parent` is one step further out.
    let mut selection: Option<SelectionRange> = None;
    for range in ranges.iter().rev() {
        selection = Some(SelectionRange {
            range: text_range_to_lsp_range(line_index, *range, encoding),
            parent: selection.map(Box::new),
        });
    }
    selection.expect("ranges is non-empty")
}

/// The token at `offset`, preferring a non-trivia side when the offset falls on a
/// token boundary so the cursor between a name and surrounding whitespace still
/// selects the name.
fn token_at(root: &SyntaxNode, offset: TextSize) -> Option<SyntaxToken> {
    let is_trivia = |kind| matches!(kind, SyntaxKind::WHITESPACE | SyntaxKind::NEWLINE);
    match root.token_at_offset(offset) {
        TokenAtOffset::None => None,
        TokenAtOffset::Single(token) => Some(token),
        TokenAtOffset::Between(left, right) => {
            if !is_trivia(right.kind()) {
                Some(right)
            } else if !is_trivia(left.kind()) {
                Some(left)
            } else {
                Some(right)
            }
        }
    }
}