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

//! `equals-null`: comparisons with `NULL` produce a zero-length logical value,
//! not a scalar null test. Membership is reported but never fixed because
//! `%in% NULL` is not equivalent to `is.null()`.

use crate::linter::diagnostic::{Diagnostic, Fix, ViolationData};
use crate::linter::rules::matchers::{self, ConstantComparisonOp};
use crate::linter::rules::{Example, Rule, RuleContext};
use crate::syntax::{SyntaxElement, SyntaxKind};

pub struct EqualsNull;

impl Rule for EqualsNull {
    fn id(&self) -> &'static str {
        "equals-null"
    }

    fn description(&self) -> &'static str {
        "Flag `==`, `!=`, and `%in%` comparisons with `NULL`; use `is.null()` for a scalar null test."
    }

    fn examples(&self) -> &'static [Example] {
        &[Example {
            caption: "Comparing a value with `NULL`:",
            source: "if (x == NULL) handle_null()\n",
        }]
    }

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

    fn check(&self, el: &SyntaxElement, ctx: &RuleContext<'_>, sink: &mut Vec<Diagnostic>) {
        let Some(node) = el.as_node() else { return };
        let Some((operand, op, _)) = matchers::constant_comparison(node, matchers::is_null) else {
            return;
        };
        let range = node.text_range();
        let fixable = ctx.introduced_call_resolves_to_base("is.null")
            && match op {
                ConstantComparisonOp::Equal => true,
                ConstantComparisonOp::NotEqual => matchers::is_safe_splice_context(node),
                ConstantComparisonOp::In => false,
            };
        let fix = fixable.then(|| {
            let test = format!("is.null({})", matchers::element_text(&operand));
            let replacement = if op == ConstantComparisonOp::NotEqual {
                format!("!{test}")
            } else {
                test
            };
            Fix::safe(
                range.start().into(),
                range.end().into(),
                replacement,
                "Use `is.null()`",
            )
        });
        sink.push(Diagnostic {
            rule: "equals-null",
            severity: Default::default(),
            path: Default::default(),
            range,
            message: ViolationData::new(
                "equals-null",
                "comparison with `NULL` does not produce a scalar null test",
            )
            .with_suggestion("Use `is.null(x)`."),
            fix,
        });
    }
}