arity 0.5.0

An LSP, 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
94
95

//! `assignment-in-condition`: `<-`, `=`, `<<-`, `:=` as the direct condition of
//! an `if`/`while`. R's `=` is often a `==` typo; the other operators are
//! almost never what you mean inside a condition.

use rowan::NodeOrToken;

use crate::linter::diagnostic::{Diagnostic, Fix, Severity, ViolationData};
use crate::linter::rules::{Rule, RuleContext};
use crate::syntax::{SyntaxElement, SyntaxKind, SyntaxNode};

pub struct AssignmentInCondition;

impl Rule for AssignmentInCondition {
    fn id(&self) -> &'static str {
        "assignment-in-condition"
    }

    fn default_severity(&self) -> Severity {
        Severity::Warning
    }

    fn interests(&self) -> &'static [SyntaxKind] {
        &[SyntaxKind::IF_EXPR, SyntaxKind::WHILE_EXPR]
    }

    fn check(&self, el: &SyntaxElement, _ctx: &RuleContext<'_>, sink: &mut Vec<Diagnostic>) {
        let Some(node) = el.as_node() else {
            return;
        };
        if let Some(assign) = direct_assignment_in_condition(node) {
            // Only the bare `=` form gets an autofix (`=` → `==`);
            // `<-`/`<<-`/`:=` in a condition are too ambiguous to
            // rewrite automatically.
            let fix = assign
                .children_with_tokens()
                .find(|e| e.kind() == SyntaxKind::ASSIGN_EQ)
                .and_then(|e| e.into_token())
                .map(|tok| {
                    let r = tok.text_range();
                    Fix::safe(
                        usize::from(r.start()),
                        usize::from(r.end()),
                        "==",
                        "Replace `=` with `==`",
                    )
                });
            sink.push(Diagnostic {
                rule: "assignment-in-condition",
                severity: Severity::Warning,
                path: Default::default(),
                range: assign.text_range(),
                message: ViolationData::new(
                    "assignment-in-condition",
                    "assignment used as a condition; did you mean `==`?",
                )
                .with_suggestion("Replace `=` with `==` or move the assignment out."),
                fix,
            });
        }
    }
}

fn direct_assignment_in_condition(if_or_while: &SyntaxNode) -> Option<SyntaxNode> {
    // The condition lives between the LPAREN and the matching RPAREN at the
    // outermost paren depth. We find the LPAREN, then look at the immediate
    // expression child(ren) between LPAREN and the matching RPAREN.
    let elements: Vec<_> = if_or_while.children_with_tokens().collect();
    let lparen_idx = elements
        .iter()
        .position(|e| e.kind() == SyntaxKind::LPAREN)?;
    let mut depth = 0usize;
    let mut rparen_idx = None;
    for (i, el) in elements.iter().enumerate().skip(lparen_idx) {
        match el.kind() {
            SyntaxKind::LPAREN => depth += 1,
            SyntaxKind::RPAREN => {
                depth = depth.saturating_sub(1);
                if depth == 0 {
                    rparen_idx = Some(i);
                    break;
                }
            }
            _ => {}
        }
    }
    let rparen_idx = rparen_idx?;
    for el in &elements[lparen_idx + 1..rparen_idx] {
        if let NodeOrToken::Node(node) = el
            && node.kind() == SyntaxKind::ASSIGNMENT_EXPR
        {
            return Some(node.clone());
        }
    }
    None
}