lisette-semantics 0.2.13

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

use diagnostics::LisetteDiagnostic;
use rustc_hash::FxHashMap as HashMap;
use syntax::ast::{BinaryOperator, Expression, Span};
use syntax::program::File;

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

pub fn check_duplicate_logical_operand(
    expression: &Expression,
    files: &HashMap<u32, File>,
    diagnostics: &mut Vec<LisetteDiagnostic>,
) {
    let Expression::Binary {
        operator,
        left,
        right,
        span,
        ..
    } = expression
    else {
        return;
    };

    if !matches!(operator, BinaryOperator::And | BinaryOperator::Or) {
        return;
    }

    let left_inner = left.unwrap_parens();
    let right_inner = right.unwrap_parens();

    // `f() && f()` may be intentional double-invocation; only warn when both
    // sides have no observable effect.
    if !is_side_effect_free(left_inner) || !is_side_effect_free(right_inner) {
        return;
    }

    if !expressions_equivalent(left_inner, right_inner) {
        return;
    }

    let Some(operand_text) = source_text(left.get_span(), files) else {
        return;
    };

    diagnostics.push(diagnostics::lint::duplicate_logical_operand(
        span,
        operand_text,
    ));
}

fn source_text(span: Span, files: &HashMap<u32, File>) -> Option<&str> {
    let file = files.get(&span.file_id)?;
    file.source
        .get(span.byte_offset as usize..span.end() as usize)
}