lisette-semantics 0.4.1

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
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
121
122
123

use crate::passes::comparison::{
    Bound, flip_comparison, in_scope_comparison, is_side_effect_free, signed_integer_literal,
    tighter,
};
use crate::passes::walk::NodeCtx;
use syntax::ast::{BinaryOperator, Expression};

use super::helpers::expressions_equivalent;

/// Inspects a single `&&`/`||` of two directly-joined comparisons; flattened
/// chains and swapped-operand forms are out of scope.
pub fn check_redundant_comparison(expression: &Expression, ctx: &NodeCtx) {
    let Expression::Binary {
        operator,
        left,
        right,
        ..
    } = expression
    else {
        return;
    };

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

    let Some((left_operand, left_interval)) = comparison_interval(left) else {
        return;
    };
    let Some((right_operand, right_interval)) = comparison_interval(right) else {
        return;
    };

    if !is_side_effect_free(left_operand) || !expressions_equivalent(left_operand, right_operand) {
        return;
    }

    let left_subset = is_subset(left_interval, right_interval);
    let right_subset = is_subset(right_interval, left_interval);
    // Equal bounds are a duplicate, left to `duplicate_logical_operand`; overlap
    // and disjoint pairs are not redundant.
    if left_subset == right_subset {
        return;
    }

    let redundant_span = match operator {
        // `||` keeps the wider bound, so the narrower (subset) side is redundant.
        Or if left_subset => left.get_span(),
        Or => right.get_span(),
        // `&&` keeps the narrower bound, so the wider (superset) side is redundant.
        And if left_subset => right.get_span(),
        And => left.get_span(),
        _ => return,
    };

    ctx.sink
        .push(diagnostics::lint::redundant_comparison(&redundant_span));
}

#[derive(Clone, Copy)]
struct Interval {
    low: Bound,
    high: Bound,
}

/// The interval a `variable OP literal` comparison constrains its operand to,
/// paired with that operand. `None` for anything that is not such a comparison.
fn comparison_interval(expression: &Expression) -> Option<(&Expression, Interval)> {
    let Expression::Binary {
        operator,
        left,
        right,
        ..
    } = expression.unwrap_parens()
    else {
        return None;
    };

    use BinaryOperator::*;
    let left = left.unwrap_parens();
    let right = right.unwrap_parens();
    if !in_scope_comparison(left, right) {
        return None;
    }
    let (operand, operator, bound) =
        match (signed_integer_literal(left), signed_integer_literal(right)) {
            (None, Some(bound)) => (left, *operator, bound),
            (Some(bound), None) => (right, flip_comparison(*operator), bound),
            _ => return None,
        };

    let interval = match operator {
        LessThan => Interval {
            low: None,
            high: Some((bound, false)),
        },
        LessThanOrEqual => Interval {
            low: None,
            high: Some((bound, true)),
        },
        GreaterThan => Interval {
            low: Some((bound, false)),
            high: None,
        },
        GreaterThanOrEqual => Interval {
            low: Some((bound, true)),
            high: None,
        },
        Equal => Interval {
            low: Some((bound, true)),
            high: Some((bound, true)),
        },
        _ => return None,
    };

    Some((operand, interval))
}

/// True when every value allowed by `a` is also allowed by `b`.
fn is_subset(a: Interval, b: Interval) -> bool {
    tighter(a.low, b.low, |x, y| x > y) == a.low && tighter(a.high, b.high, |x, y| x < y) == a.high
}