grit_pattern_matcher/pattern/
modulo.rs

1use super::{
2    patterns::{Matcher, Pattern, PatternName},
3    resolved_pattern::ResolvedPattern,
4    state::State,
5};
6use crate::{
7    constant::Constant,
8    context::{ExecContext, QueryContext},
9};
10use grit_util::{error::GritResult, AnalysisLogs};
11
12#[derive(Debug, Clone)]
13pub struct Modulo<Q: QueryContext> {
14    pub lhs: Pattern<Q>,
15    pub rhs: Pattern<Q>,
16}
17
18impl<Q: QueryContext> Modulo<Q> {
19    pub fn new(lhs: Pattern<Q>, rhs: Pattern<Q>) -> Self {
20        Self { lhs, rhs }
21    }
22
23    pub fn call<'a>(
24        &'a self,
25        state: &mut State<'a, Q>,
26        context: &'a Q::ExecContext<'a>,
27        logs: &mut AnalysisLogs,
28    ) -> GritResult<Q::ResolvedPattern<'a>> {
29        let res = self.evaluate(state, context, logs)?;
30        Ok(Q::ResolvedPattern::from_constant(Constant::Integer(res)))
31    }
32
33    fn evaluate<'a>(
34        &'a self,
35        state: &mut State<'a, Q>,
36        context: &'a Q::ExecContext<'a>,
37        logs: &mut AnalysisLogs,
38    ) -> GritResult<i64> {
39        let lhs = self.lhs.text(state, context, logs)?;
40        let rhs = self.rhs.text(state, context, logs)?;
41        let lhs_int = lhs.parse::<i64>()?;
42        let rhs_int = rhs.parse::<i64>()?;
43        let res = lhs_int % rhs_int;
44        Ok(res)
45    }
46}
47
48impl<Q: QueryContext> PatternName for Modulo<Q> {
49    fn name(&self) -> &'static str {
50        "MODULO"
51    }
52}
53
54impl<Q: QueryContext> Matcher<Q> for Modulo<Q> {
55    fn execute<'a>(
56        &'a self,
57        binding: &Q::ResolvedPattern<'a>,
58        state: &mut State<'a, Q>,
59        context: &'a Q::ExecContext<'a>,
60        logs: &mut AnalysisLogs,
61    ) -> GritResult<bool> {
62        let binding_text = binding.text(&state.files, context.language())?;
63        let binding_int = binding_text.parse::<i64>()?;
64        let target = self.evaluate(state, context, logs)?;
65        Ok(binding_int == target)
66    }
67}