fatou 0.22.0

A language server, formatter, and linter for Julia
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

//! `test-isa-call`: Test assertions using the function-call spelling
//! `@test isa(value, Type)` instead of Julia's comparison spelling
//! `@test value isa Type`.
//!
//! The two expressions lower to the same call—even when `isa` is shadowed—so
//! the rewrite preserves behavior. The shared Test matcher ensures this is a
//! real, in-scope stdlib assertion rather than an unrelated macro named
//! `@test`.

use crate::ast::{AstNode, AstToken, CallExpr, Expr, MacroCall};
use crate::linter::diagnostic::{Applicability, Diagnostic, Fix};
use crate::linter::rules::matchers;
use crate::linter::rules::test_matchers::test_invocation;
use crate::linter::rules::{Example, Rule, RuleContext};
use crate::syntax::{SyntaxElement, SyntaxKind};

pub struct TestIsaCall;

impl Rule for TestIsaCall {
    fn id(&self) -> &'static str {
        "test-isa-call"
    }

    fn description(&self) -> &'static str {
        "Flag `@test isa(value, Type)` and prefer `@test value isa Type`. The \
         rule only matches the real `Test.@test` macro after a visible, \
         file-local Test load. It reports a safe fix that reuses both \
         arguments' source text and adds parentheses when an operand would \
         otherwise rebind. The fix is withheld when it would discard a \
         comment outside the retained arguments."
    }

    fn examples(&self) -> &'static [Example] {
        &[Example {
            caption: "Use Julia's comparison spelling in a Test assertion:",
            source: "using Test\n@test isa(result, AbstractVector)\n",
        }]
    }

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

    fn check(&self, el: &SyntaxElement, ctx: &RuleContext<'_>, sink: &mut Vec<Diagnostic>) {
        let Some(macro_call) = el.as_node().cloned().and_then(MacroCall::cast) else {
            return;
        };
        let Some(invocation) = test_invocation(&macro_call, ctx) else {
            return;
        };
        let Expr::CallExpr(isa_call) = invocation.expression else {
            return;
        };
        let Some((_call, args)) = matchers::plain_call(isa_call.syntax(), "isa", 2) else {
            return;
        };
        let [value, ty]: [Expr; 2] = args.try_into().expect("plain arity checked");
        let replacement = format!("{} isa {}", operand_text(&value), operand_text(&ty));
        let range = isa_call.syntax().text_range();
        let mut diag = Diagnostic::new(
            self.id(),
            range,
            format!("write `{replacement}` instead of calling `isa`"),
        );
        if !drops_comment_outside_arguments(&isa_call, [&value, &ty]) {
            diag.fixes.push(Fix {
                description: "Rewrite as an `isa` comparison".to_string(),
                content: replacement,
                start: range.start().into(),
                end: range.end().into(),
                applicability: Applicability::Safe,
            });
        }
        sink.push(diag);
    }
}

fn operand_text(expr: &Expr) -> String {
    let text = expr.syntax().text().to_string();
    if binds_at_least_as_tightly_as_isa(expr) {
        text
    } else {
        format!("({text})")
    }
}

fn binds_at_least_as_tightly_as_isa(expr: &Expr) -> bool {
    matches!(
        expr,
        Expr::Literal(_)
            | Expr::StringLiteral(_)
            | Expr::CmdLiteral(_)
            | Expr::NonstandardIdentifier(_)
            | Expr::Name(_)
            | Expr::UnaryExpr(_)
            | Expr::ParenExpr(_)
            | Expr::TupleExpr(_)
            | Expr::VectExpr(_)
            | Expr::MatrixExpr(_)
            | Expr::Comprehension(_)
            | Expr::Braces(_)
            | Expr::CurlyExpr(_)
            | Expr::CallExpr(_)
            | Expr::IndexExpr(_)
            | Expr::DotCallExpr(_)
    ) || matches!(expr, Expr::BinaryExpr(bin) if bin.op().is_some_and(|op| op.text() == "."))
}

fn drops_comment_outside_arguments(call: &CallExpr, args: [&Expr; 2]) -> bool {
    let outer = call.syntax().text_range();
    let text = call.syntax().text().to_string();
    let mut stripped = text;
    for arg in args.iter().rev() {
        let range = arg.syntax().text_range();
        let start = usize::from(range.start() - outer.start());
        let end = usize::from(range.end() - outer.start());
        stripped.replace_range(start..end, "");
    }
    stripped.contains('#')
}