arity 0.2.0

An LSP, formatter, and linter for R
Documentation 
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

//! `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::{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 run(&self, ctx: &RuleContext<'_>) -> Vec<Diagnostic> {
        let mut out = Vec::new();
        for node in ctx.root.descendants() {
            match node.kind() {
                SyntaxKind::IF_EXPR | SyntaxKind::WHILE_EXPR => {
                    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 `==`",
                                )
                            });
                        out.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,
                        });
                    }
                }
                _ => {}
            }
        }
        out
    }
}

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
}