grit_pattern_matcher/pattern/
modulo.rs1use 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}