rrubocop 0.8.15

10x faster RuboCop drop-in. Same output format and configs, without maintaining RuboCop gems.
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

//! Pattern-match `=>` recovery ERRORs that MRI accepts.

use tree_sitter::Node;

use crate::cop::shared::node_bytes;
use crate::parse::source::SourceFile;

/// Multiline rightward assignment `expr =>\n  key:` — tree-sitter often splits later
/// keys into `left_assignment_list` with ERROR `:` after a preceding `match_pattern`.
pub(super) fn pattern_match_arrow_error(source: &SourceFile, node: Node<'_>) -> bool {
    node.is_error()
        && looks_like_keyword_pattern_fragment(source, node)
        && (error_in_pattern_lhs_list(source, node)
            || node
                .parent()
                .is_some_and(|p| after_match_pattern_continuation(source, p, node)))
}

fn is_ident_name(s: &str) -> bool {
    !s.is_empty() && s.chars().all(|c| c.is_alphanumeric() || c == '_')
}

fn looks_like_keyword_pattern_fragment(source: &SourceFile, node: Node<'_>) -> bool {
    let t = node_bytes(source, node);
    if matches!(t, b":" | b":," | b",") {
        return true;
    }
    let Ok(s) = std::str::from_utf8(t) else {
        return false;
    };
    let Some((name, rest)) = s.trim().split_once(':') else {
        return false;
    };
    let rest = rest.trim().trim_end_matches(',').trim();
    is_ident_name(name) && (rest.is_empty() || is_ident_name(rest))
}

fn match_pattern_has_arrow(source: &SourceFile, node: Node<'_>) -> bool {
    let mut cur = node.walk();
    node.children(&mut cur)
        .any(|c| c.kind() == "=>" || node_bytes(source, c) == b"=>")
}

fn sibling_before<'a>(parent: Node<'a>, child: Node<'a>) -> Vec<Node<'a>> {
    let mut cur = parent.walk();
    let kids: Vec<_> = parent.children(&mut cur).collect();
    let Some(idx) = kids.iter().position(|k| k.id() == child.id()) else {
        return Vec::new();
    };
    kids[..idx].to_vec()
}

fn preceding_match_pattern(source: &SourceFile, parent: Node<'_>, child: Node<'_>) -> bool {
    sibling_before(parent, child).iter().rev().any(|k| {
        k.kind() == "match_pattern" && match_pattern_has_arrow(source, *k)
    })
}

fn continuation_gap_ok(kids: &[Node<'_>]) -> bool {
    kids.iter()
        .all(|k| matches!(k.kind(), "identifier" | "comment") || k.is_error())
}

fn after_match_pattern_continuation(
    source: &SourceFile,
    parent: Node<'_>,
    child: Node<'_>,
) -> bool {
    let before = sibling_before(parent, child);
    let Some(mp) = before
        .iter()
        .rposition(|k| k.kind() == "match_pattern" && match_pattern_has_arrow(source, *k))
    else {
        return false;
    };
    continuation_gap_ok(&before[mp + 1..])
}

fn error_in_pattern_lhs_list(source: &SourceFile, node: Node<'_>) -> bool {
    let Some(lal) = node.parent().filter(|p| p.kind() == "left_assignment_list") else {
        return false;
    };
    let Some(assign) = lal.parent().filter(|p| p.kind() == "assignment") else {
        return false;
    };
    assign
        .parent()
        .is_some_and(|body| preceding_match_pattern(source, body, assign))
}