lisette-semantics 0.2.16

Little language inspired by Rust that compiles to Go
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

use diagnostics::LisetteDiagnostic;
use syntax::ast::Expression;

use super::helpers::{expressions_equivalent, is_side_effect_free};

/// (module_id, function_name, arg index a, arg index b)
const DUP_ARG_TARGETS: &[(&str, &str, usize, usize)] = &[
    ("go:math", "Max", 0, 1),
    ("go:math", "Min", 0, 1),
    ("go:reflect", "DeepEqual", 0, 1),
    ("go:bytes", "Equal", 0, 1),
    ("go:bytes", "Compare", 0, 1),
    ("go:bytes", "EqualFold", 0, 1),
    ("go:strings", "Compare", 0, 1),
    ("go:strings", "EqualFold", 0, 1),
    ("go:strings", "Replace", 1, 2),
    ("go:strings", "ReplaceAll", 1, 2),
];

pub fn check_dup_arg(expression: &Expression, diagnostics: &mut Vec<LisetteDiagnostic>) {
    let Expression::Call {
        expression: callee,
        args,
        span,
        ..
    } = expression
    else {
        return;
    };

    let Expression::DotAccess {
        expression: namespace,
        member,
        ..
    } = callee.unwrap_parens()
    else {
        return;
    };

    let namespace_ty = namespace.get_type();
    let Some(module_id) = namespace_ty.as_import_namespace() else {
        return;
    };

    for (target_module, target_function, a, b) in DUP_ARG_TARGETS {
        if module_id != *target_module || member != *target_function {
            continue;
        }
        let (Some(arg_a), Some(arg_b)) = (args.get(*a), args.get(*b)) else {
            return;
        };
        if !is_side_effect_free(arg_a) || !is_side_effect_free(arg_b) {
            return;
        }
        if !expressions_equivalent(arg_a, arg_b) {
            return;
        }
        diagnostics.push(diagnostics::lint::duplicate_arguments(
            span,
            target_module,
            target_function,
        ));
        return;
    }
}