use syntax::ast::{Expression, Literal};
pub(super) fn bool_literal(expression: &Expression) -> Option<bool> {
if let Expression::Literal {
literal: Literal::Boolean(b),
..
} = expression
{
Some(*b)
} else {
None
}
}
pub(super) fn is_empty_block(expression: &Expression) -> bool {
matches!(expression, Expression::Block { items, .. } if items.is_empty())
}
pub(super) fn is_side_effect_free(expression: &Expression) -> bool {
match expression.unwrap_parens() {
Expression::Identifier { .. } | Expression::Literal { .. } => true,
Expression::Unary {
expression: inner, ..
} => is_side_effect_free(inner),
Expression::Binary { left, right, .. } => {
is_side_effect_free(left) && is_side_effect_free(right)
}
Expression::DotAccess {
expression: inner, ..
} => is_side_effect_free(inner),
_ => false,
}
}
pub(super) fn expressions_equivalent(a: &Expression, b: &Expression) -> bool {
let a = a.unwrap_parens();
let b = b.unwrap_parens();
match (a, b) {
(Expression::Identifier { value: av, .. }, Expression::Identifier { value: bv, .. }) => {
av == bv
}
(Expression::Literal { literal: al, .. }, Expression::Literal { literal: bl, .. }) => {
al == bl
}
(
Expression::Unary {
operator: ao,
expression: ae,
..
},
Expression::Unary {
operator: bo,
expression: be,
..
},
) => ao == bo && expressions_equivalent(ae, be),
(
Expression::Binary {
operator: ao,
left: al,
right: ar,
..
},
Expression::Binary {
operator: bo,
left: bl,
right: br,
..
},
) => ao == bo && expressions_equivalent(al, bl) && expressions_equivalent(ar, br),
(
Expression::DotAccess {
expression: ae,
member: am,
..
},
Expression::DotAccess {
expression: be,
member: bm,
..
},
) => am == bm && expressions_equivalent(ae, be),
(Expression::Block { items: ai, .. }, Expression::Block { items: bi, .. }) => {
ai.len() == bi.len() && ai.iter().zip(bi).all(|(x, y)| expressions_equivalent(x, y))
}
(
Expression::Call {
expression: ac,
args: aa,
..
},
Expression::Call {
expression: bc,
args: ba,
..
},
) => {
expressions_equivalent(ac, bc)
&& aa.len() == ba.len()
&& aa.iter().zip(ba).all(|(x, y)| expressions_equivalent(x, y))
}
_ => false,
}
}