lisette-semantics 0.4.2

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
66
67
68

use crate::passes::comparison::{MinMaxOp, prelude_min_max, signed_integer_literal};
use crate::passes::walk::NodeCtx;
use syntax::ast::Expression;
use syntax::types::SimpleKind;

pub(crate) fn check(expression: &Expression, ctx: &NodeCtx) {
    let span = expression.get_span();
    if ctx.claimed_spans.borrow().contains(&span) {
        return;
    }

    let Some(outer) = prelude_min_max(expression) else {
        return;
    };

    // Integers only: a float clamp can yield NaN, which Go's `min`/`max`
    // propagate, so the result is not constant.
    let Some(kind) = expression.get_type().as_simple() else {
        return;
    };
    if kind.integer_range().is_none() {
        return;
    }

    let (outer_constant, nested) = match (
        in_range_literal(outer.left, kind),
        in_range_literal(outer.right, kind),
    ) {
        (Some(constant), None) => (constant, outer.right),
        (None, Some(constant)) => (constant, outer.left),
        _ => return,
    };

    let nested = nested.unwrap_parens();
    let Some(inner) = prelude_min_max(nested) else {
        return;
    };
    if inner.op == outer.op {
        return;
    }

    let inner_constant = match (
        in_range_literal(inner.left, kind),
        in_range_literal(inner.right, kind),
    ) {
        (Some(constant), None) | (None, Some(constant)) => constant,
        _ => return,
    };

    let always_constant = match outer.op {
        MinMaxOp::Min => outer_constant <= inner_constant,
        MinMaxOp::Max => outer_constant >= inner_constant,
    };
    if !always_constant {
        return;
    }

    ctx.claimed_spans.borrow_mut().insert(nested.get_span());
    ctx.sink
        .push(diagnostics::infer::min_max(&span, outer_constant));
}

// In range for `kind`, so the lint never fires on a literal the checker rejects.
fn in_range_literal(expression: &Expression, kind: SimpleKind) -> Option<i128> {
    let value = signed_integer_literal(expression.unwrap_parens())?;
    let (min, max) = kind.integer_range()?;
    (min <= value && value <= max).then_some(value)
}