arity 0.20.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
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
140
141
142
143
144
145

//! `all-equal`: using `all.equal()` itself as a logical test.
//!
//! Base R's `all.equal()` returns `TRUE` for equality, but a character vector
//! describing the differences otherwise. Testing that value directly does not
//! test equality. The intended predicate is `isTRUE(all.equal(...))`.
//!
//! This is namespace-confirmed (`ns`): both `all.equal()` and an enclosing
//! `isFALSE()` must resolve to base R. Rewrites are unsafe because they repair
//! behavior that existing code may, however unusually, rely on.

use rowan::ast::AstNode as _;

use crate::ast::{CallExpr, IfExpr, ParenExpr, UnaryExpr, WhileExpr};
use crate::linter::diagnostic::{Diagnostic, Fix, ViolationData};
use crate::linter::rules::matchers;
use crate::linter::rules::{Example, Rule, RuleContext};
use crate::syntax::{SyntaxElement, SyntaxKind};

pub struct AllEqual;

const EXAMPLES: &[Example] = &[Example {
    caption: "Testing the return value of `all.equal()` directly:",
    source: "if (all.equal(actual, expected)) pass()\n",
}];

impl Rule for AllEqual {
    fn id(&self) -> &'static str {
        "all-equal"
    }

    fn description(&self) -> &'static str {
        "Flag `all.equal()` used directly as a condition, negated, or passed to \
         `isFALSE()`. A disagreement returns a character vector rather than \
         `FALSE`, so these forms do not reliably test equality. Use \
         `isTRUE(all.equal(...))` instead. Only base-R callees are flagged. The \
         fix is unsafe because it deliberately changes existing behavior."
    }

    fn examples(&self) -> &'static [Example] {
        EXAMPLES
    }

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

    fn check(&self, el: &SyntaxElement, ctx: &RuleContext<'_>, sink: &mut Vec<Diagnostic>) {
        let Some((tested, range, replacement)) = tested_all_equal(el, ctx) else {
            return;
        };
        if !ctx.resolves_to_base(&tested) {
            return;
        }

        let fix = replacement.map(|content| {
            Fix::unsafe_(
                usize::from(range.start()),
                usize::from(range.end()),
                content,
                "Test `all.equal()` with `isTRUE()`",
            )
        });
        sink.push(Diagnostic {
            rule: "all-equal",
            severity: Default::default(),
            path: Default::default(),
            range,
            message: ViolationData::new(
                "all-equal",
                "`all.equal()` does not return `FALSE` for unequal objects",
            )
            .with_suggestion("Use `isTRUE(all.equal(...))` to test equality."),
            fix,
        });
    }
}

fn tested_all_equal(
    el: &SyntaxElement,
    ctx: &RuleContext<'_>,
) -> Option<(CallExpr, rowan::TextRange, Option<String>)> {
    let node = el.as_node()?.clone();
    match node.kind() {
        SyntaxKind::IF_EXPR | SyntaxKind::WHILE_EXPR => {
            let elements = IfExpr::cast(node.clone())
                .and_then(|expr| expr.condition_elements())
                .or_else(|| WhileExpr::cast(node)?.condition_elements())?;
            let condition = elements.into_iter().find(|part| !is_trivia(part.kind()))?;
            let call = all_equal_call(&condition)?;
            let range = condition.text_range();
            Some((call, range, Some(format!("isTRUE({condition})"))))
        }
        SyntaxKind::UNARY_EXPR => {
            let unary = UnaryExpr::cast(node)?;
            if unary.op_kind() != Some(SyntaxKind::BANG) {
                return None;
            }
            let operand = unary.operand()?;
            let call = all_equal_call(&operand)?;
            let range = unary.syntax().text_range();
            Some((call, range, Some(format!("!isTRUE({operand})"))))
        }
        SyntaxKind::CALL_EXPR => {
            let outer = CallExpr::cast(node)?;
            if matchers::callee_name(&outer).as_deref() != Some("isFALSE")
                || !ctx.resolves_to_base(&outer)
            {
                return None;
            }
            let argument = matchers::sole_positional(&outer)?;
            let call = all_equal_call(&argument)?;
            let range = outer.syntax().text_range();
            let replacement = (!outer
                .syntax()
                .descendants_with_tokens()
                .any(|part| part.kind() == SyntaxKind::COMMENT))
            .then(|| format!("!isTRUE({argument})"));
            Some((call, range, replacement))
        }
        _ => None,
    }
}

fn all_equal_call(element: &SyntaxElement) -> Option<CallExpr> {
    if let Some(node) = element.as_node() {
        if let Some(call) = matchers::call_named(node, "all.equal") {
            return Some(call);
        }
        if node.kind() == SyntaxKind::PAREN_EXPR {
            return ParenExpr::cast(node.clone())
                .and_then(|paren| paren.inner())
                .and_then(|inner| all_equal_call(&inner));
        }
    }
    None
}

fn is_trivia(kind: SyntaxKind) -> bool {
    matches!(kind, SyntaxKind::WHITESPACE | SyntaxKind::NEWLINE)
}