Skip to main content

tonneau_build/codegen/cel/compiler/
resolve.rs

1use cel_parser::{ArithmeticOp, Atom, Expression, Member, RelationOp};
2use quote::quote;
3use syn::parse_quote;
4use tonneau_cel::CelValue;
5
6use super::{
7    CompileError, CompiledExpr, Compiler, CompilerCtx, ConstantCompiledExpr, RuntimeCompiledExpr,
8};
9use crate::codegen::cel::types::CelType;
10use crate::types::{ProtoModifiedValueType, ProtoType, ProtoValueType};
11
12pub(crate) fn resolve(ctx: &Compiler, expr: &Expression) -> Result<CompiledExpr, CompileError> {
13    match expr {
14        Expression::And(left, right) => resolve_and(ctx, left, right),
15        Expression::Arithmetic(left, op, right) => resolve_arithmetic(ctx, left, op, right),
16        Expression::Atom(atom) => resolve_atom(ctx, atom),
17        Expression::FunctionCall(func, this, args) => {
18            resolve_function_call(ctx, func, this.as_deref(), args)
19        }
20        Expression::Ident(ident) => resolve_ident(ctx, ident),
21        Expression::List(items) => resolve_list(ctx, items),
22        Expression::Map(items) => resolve_map(ctx, items),
23        Expression::Member(expr, member) => resolve_member(ctx, expr, member),
24        Expression::Or(left, right) => resolve_or(ctx, left, right),
25        Expression::Relation(left, op, right) => resolve_relation(ctx, left, op, right),
26        Expression::Ternary(cond, left, right) => resolve_ternary(ctx, cond, left, right),
27        Expression::Unary(op, expr) => resolve_unary(ctx, op, expr),
28    }
29}
30
31fn resolve_and(
32    ctx: &Compiler,
33    left: &Expression,
34    right: &Expression,
35) -> Result<CompiledExpr, CompileError> {
36    let left = ctx.resolve(left)?.into_bool(ctx);
37    let right = ctx.resolve(right)?.into_bool(ctx);
38    match (left, right) {
39        (
40            CompiledExpr::Constant(ConstantCompiledExpr { value: left }),
41            CompiledExpr::Constant(ConstantCompiledExpr { value: right }),
42        ) => Ok(CompiledExpr::constant(left.to_bool() && right.to_bool())),
43        (CompiledExpr::Constant(ConstantCompiledExpr { value: const_value }), other)
44        | (other, CompiledExpr::Constant(ConstantCompiledExpr { value: const_value })) => {
45            if const_value.to_bool() {
46                Ok(other)
47            } else {
48                Ok(CompiledExpr::constant(false))
49            }
50        }
51        (left, right) => Ok(CompiledExpr::runtime(
52            CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
53            parse_quote! {
54                (#left) && (#right)
55            },
56        )),
57    }
58}
59
60fn resolve_arithmetic(
61    ctx: &Compiler,
62    left: &Expression,
63    op: &ArithmeticOp,
64    right: &Expression,
65) -> Result<CompiledExpr, CompileError> {
66    let left = ctx.resolve(left)?.into_cel()?;
67    let right = ctx.resolve(right)?.into_cel()?;
68    match (left, right) {
69        (
70            CompiledExpr::Constant(ConstantCompiledExpr { value: left }),
71            CompiledExpr::Constant(ConstantCompiledExpr { value: right }),
72        ) => match op {
73            ArithmeticOp::Add => Ok(CompiledExpr::constant(CelValue::cel_add(left, right)?)),
74            ArithmeticOp::Subtract => Ok(CompiledExpr::constant(CelValue::cel_sub(left, right)?)),
75            ArithmeticOp::Divide => Ok(CompiledExpr::constant(CelValue::cel_div(left, right)?)),
76            ArithmeticOp::Multiply => Ok(CompiledExpr::constant(CelValue::cel_mul(left, right)?)),
77            ArithmeticOp::Modulus => Ok(CompiledExpr::constant(CelValue::cel_rem(left, right)?)),
78        },
79        (left, right) => {
80            let op = match op {
81                ArithmeticOp::Add => quote! { cel_add },
82                ArithmeticOp::Subtract => quote! { cel_sub },
83                ArithmeticOp::Divide => quote! { cel_div },
84                ArithmeticOp::Multiply => quote! { cel_mul },
85                ArithmeticOp::Modulus => quote! { cel_rem },
86            };
87
88            Ok(CompiledExpr::runtime(
89                CelType::CelValue,
90                parse_quote! {
91                    ::tonneau::__private::cel::CelValue::#op(
92                        #right,
93                        #left,
94                    )?
95                },
96            ))
97        }
98    }
99}
100
101fn resolve_atom(_: &Compiler, atom: &Atom) -> Result<CompiledExpr, CompileError> {
102    match atom {
103        Atom::Int(v) => Ok(CompiledExpr::constant(v)),
104        Atom::UInt(v) => Ok(CompiledExpr::constant(v)),
105        Atom::Float(v) => Ok(CompiledExpr::constant(v)),
106        Atom::String(v) => Ok(CompiledExpr::constant(tonneau_cel::CelValue::String(
107            v.to_string().into(),
108        ))),
109        Atom::Bytes(v) => Ok(CompiledExpr::constant(tonneau_cel::CelValue::Bytes(
110            v.to_vec().into(),
111        ))),
112        Atom::Bool(v) => Ok(CompiledExpr::constant(v)),
113        Atom::Null => Ok(CompiledExpr::constant(tonneau_cel::CelValue::Null)),
114    }
115}
116
117fn resolve_function_call(
118    ctx: &Compiler,
119    func: &Expression,
120    this: Option<&Expression>,
121    args: &[Expression],
122) -> Result<CompiledExpr, CompileError> {
123    let Expression::Ident(func_name) = func else {
124        return Err(CompileError::UnsupportedFunctionCallIdentifierType(
125            func.clone(),
126        ));
127    };
128
129    let Some(func) = ctx.get_function(func_name) else {
130        return Err(CompileError::FunctionNotFound(func_name.to_string()));
131    };
132
133    let this = if let Some(this) = this {
134        Some(ctx.resolve(this)?)
135    } else {
136        None
137    };
138
139    func.compile(CompilerCtx::new(ctx.child(), this, args))
140}
141
142fn resolve_ident(ctx: &Compiler, ident: &str) -> Result<CompiledExpr, CompileError> {
143    ctx.get_variable(ident)
144        .cloned()
145        .ok_or_else(|| CompileError::VariableNotFound(ident.to_owned()))
146}
147
148fn resolve_list(ctx: &Compiler, items: &[Expression]) -> Result<CompiledExpr, CompileError> {
149    let items = items
150        .iter()
151        .map(|item| ctx.resolve(item)?.into_cel())
152        .collect::<Result<Vec<_>, _>>()?;
153
154    if items.iter().any(|i| matches!(i, CompiledExpr::Runtime(_))) {
155        Ok(CompiledExpr::runtime(
156            CelType::CelValue,
157            parse_quote! {
158                ::tonneau::__private::cel::CelValue::List(::std::iter::FromIterator::from_iter([
159                    #(#items),*
160                ]))
161            },
162        ))
163    } else {
164        Ok(CompiledExpr::constant(CelValue::List(
165            items
166                .into_iter()
167                .map(|item| match item {
168                    CompiledExpr::Constant(ConstantCompiledExpr { value }) => value,
169                    _ => unreachable!(),
170                })
171                .collect(),
172        )))
173    }
174}
175
176fn resolve_map(
177    ctx: &Compiler,
178    items: &[(Expression, Expression)],
179) -> Result<CompiledExpr, CompileError> {
180    let items = items
181        .iter()
182        .map(|(key, value)| {
183            let key = ctx.resolve(key)?.into_cel()?;
184            let value = ctx.resolve(value)?.into_cel()?;
185            Ok((key, value))
186        })
187        .collect::<Result<Vec<_>, CompileError>>()?;
188
189    if items.iter().any(|(key, value)| {
190        matches!(key, CompiledExpr::Runtime(_)) || matches!(value, CompiledExpr::Runtime(_))
191    }) {
192        let items = items.into_iter().map(|(key, value)| quote!((#key, #value)));
193        Ok(CompiledExpr::runtime(
194            CelType::CelValue,
195            parse_quote! {
196                ::tonneau::__private::cel::CelValue::Map(::std::iter::FromIterator::from_iter([
197                    #(#items),*
198                ]))
199            },
200        ))
201    } else {
202        Ok(CompiledExpr::constant(CelValue::Map(
203            items
204                .into_iter()
205                .map(|(key, value)| match (key, value) {
206                    (
207                        CompiledExpr::Constant(ConstantCompiledExpr { value: key }),
208                        CompiledExpr::Constant(ConstantCompiledExpr { value }),
209                    ) => (key, value),
210                    _ => unreachable!(),
211                })
212                .collect(),
213        )))
214    }
215}
216
217fn resolve_member(
218    ctx: &Compiler,
219    expr: &Expression,
220    member: &Member,
221) -> Result<CompiledExpr, CompileError> {
222    let expr = ctx.resolve(expr)?;
223    match member {
224        Member::Attribute(attr) => {
225            let attr = attr.as_str();
226            match &expr {
227                CompiledExpr::Runtime(RuntimeCompiledExpr {
228                    expr,
229                    ty: CelType::CelValue,
230                }) => Ok(CompiledExpr::runtime(
231                    CelType::CelValue,
232                    parse_quote! {
233                        ::tonneau::__private::cel::CelValue::access(
234                            #expr,
235                            #attr
236                        )?
237                    },
238                )),
239                CompiledExpr::Runtime(RuntimeCompiledExpr {
240                    expr,
241                    ty:
242                        ty @ CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Optional(
243                            ProtoValueType::Message(full_name),
244                        ))),
245                }) => {
246                    let msg = ctx
247                        .registry()
248                        .get_message(full_name)
249                        .ok_or_else(|| CompileError::MissingMessage(full_name.clone()))?;
250
251                    let field_ty =
252                        msg.fields
253                            .get(attr)
254                            .ok_or_else(|| CompileError::MemberAccess {
255                                ty: Box::new(ty.clone()),
256                                message: format!(
257                                    "message {} does not have field {}",
258                                    msg.full_name, attr
259                                ),
260                            })?;
261
262                    let field_ident = field_ty.rust_ident();
263
264                    Ok(CompiledExpr::runtime(
265                        CelType::Proto(field_ty.ty.clone()),
266                        parse_quote! {
267                            match (#expr) {
268                                Some(value) => &value.#field_ident,
269                                None => return Err(::tonneau::__private::cel::CelError::BadAccess {
270                                    member: ::tonneau::__private::cel::CelValue::String(::tonneau::__private::cel::CelString::Borrowed(#attr)),
271                                    container: ::tonneau::__private::cel::CelValue::Null,
272                                }),
273                            }
274                        },
275                    ))
276                }
277                CompiledExpr::Runtime(RuntimeCompiledExpr {
278                    expr,
279                    ty:
280                        ty @ CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::OneOf(oneof))),
281                }) => {
282                    let field_ty =
283                        oneof
284                            .fields
285                            .get(attr)
286                            .ok_or_else(|| CompileError::MemberAccess {
287                                ty: Box::new(ty.clone()),
288                                message: format!(
289                                    "oneof {} does not have field {}",
290                                    oneof.full_name, attr
291                                ),
292                            })?;
293
294                    let field_ident = field_ty.rust_ident();
295
296                    Ok(CompiledExpr::runtime(
297                        CelType::Proto(ProtoType::Value(field_ty.ty.clone())),
298                        parse_quote! {
299                            match (#expr) {
300                                Some(value) => &value.#field_ident,
301                                None => return Err(::tonneau::__private::cel::CelError::BadAccess {
302                                    member: ::tonneau::__private::cel::CelValue::String(::tonneau::__private::cel::CelString::Borrowed(#attr)),
303                                    container: ::tonneau::__private::cel::CelValue::Null,
304                                }),
305                            }
306                        },
307                    ))
308                }
309                CompiledExpr::Runtime(RuntimeCompiledExpr {
310                    expr,
311                    ty: ty @ CelType::Proto(ProtoType::Value(ProtoValueType::Message(full_name))),
312                }) => {
313                    let msg = ctx
314                        .registry()
315                        .get_message(full_name)
316                        .ok_or_else(|| CompileError::MissingMessage(full_name.clone()))?;
317                    let field_ty =
318                        msg.fields
319                            .get(attr)
320                            .ok_or_else(|| CompileError::MemberAccess {
321                                ty: Box::new(ty.clone()),
322                                message: format!(
323                                    "message {} does not have field {}",
324                                    msg.full_name, attr
325                                ),
326                            })?;
327
328                    let field_ident = field_ty.rust_ident();
329
330                    Ok(CompiledExpr::runtime(
331                        CelType::Proto(field_ty.ty.clone()),
332                        parse_quote! {
333                            &(#expr).#field_ident
334                        },
335                    ))
336                }
337                CompiledExpr::Runtime(RuntimeCompiledExpr {
338                    expr,
339                    ty:
340                        CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Map(
341                            ProtoValueType::String,
342                            value_ty,
343                        ))),
344                }) => Ok(CompiledExpr::runtime(
345                    CelType::Proto(ProtoType::Value(value_ty.clone())),
346                    parse_quote! {
347                        ::tonneau::__private::cel::map_access(
348                            #expr,
349                            #attr,
350                        )?
351                    },
352                )),
353                CompiledExpr::Runtime(RuntimeCompiledExpr { ty, .. }) => {
354                    Err(CompileError::MemberAccess {
355                        ty: Box::new(ty.clone()),
356                        message: "can only access attributes on messages and maps with string keys"
357                            .to_string(),
358                    })
359                }
360                CompiledExpr::Constant(ConstantCompiledExpr { value: container }) => Ok(
361                    CompiledExpr::constant(tonneau_cel::CelValue::cel_access(container, attr)?),
362                ),
363            }
364        }
365        Member::Index(idx) => {
366            let idx = ctx.resolve(idx)?.into_cel()?;
367            match (expr, idx) {
368                (
369                    expr @ CompiledExpr::Runtime(RuntimeCompiledExpr {
370                        ty: CelType::CelValue,
371                        ..
372                    }),
373                    idx,
374                )
375                | (expr @ CompiledExpr::Constant(_), idx @ CompiledExpr::Runtime(_)) => {
376                    Ok(CompiledExpr::runtime(
377                        CelType::CelValue,
378                        parse_quote! {
379                            ::tonneau::__private::cel::CelValue::cel_access(#expr, #idx)?
380                        },
381                    ))
382                }
383                (
384                    CompiledExpr::Runtime(RuntimeCompiledExpr {
385                        expr,
386                        ty:
387                            CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Repeated(
388                                item_ty,
389                            ))),
390                    }),
391                    idx,
392                ) => Ok(CompiledExpr::runtime(
393                    CelType::Proto(ProtoType::Value(item_ty.clone())),
394                    parse_quote! {
395                        ::tonneau::__private::cel::CelValueConv::array_access(
396                            #expr,
397                            #idx,
398                        )?
399                    },
400                )),
401                (
402                    CompiledExpr::Runtime(RuntimeCompiledExpr {
403                        expr,
404                        ty:
405                            CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Map(
406                                _,
407                                value_ty,
408                            ))),
409                    }),
410                    idx,
411                ) => Ok(CompiledExpr::runtime(
412                    CelType::Proto(ProtoType::Value(value_ty.clone())),
413                    parse_quote! {
414                        ::tonneau::__private::cel::map_access(
415                            #expr,
416                            #idx,
417                        )?
418                    },
419                )),
420                (CompiledExpr::Runtime(RuntimeCompiledExpr { ty, .. }), _) => {
421                    Err(CompileError::MemberAccess {
422                        ty: Box::new(ty.clone()),
423                        message: "cannot index into non-repeated and non-map values".to_string(),
424                    })
425                }
426                (
427                    CompiledExpr::Constant(ConstantCompiledExpr { value: container }),
428                    CompiledExpr::Constant(ConstantCompiledExpr { value: idx }),
429                ) => Ok(CompiledExpr::constant(tonneau_cel::CelValue::cel_access(
430                    container, idx,
431                )?)),
432            }
433        }
434        Member::Fields(_) => Err(CompileError::NotImplemented),
435    }
436}
437
438fn resolve_or(
439    ctx: &Compiler,
440    left: &Expression,
441    right: &Expression,
442) -> Result<CompiledExpr, CompileError> {
443    let left = ctx.resolve(left)?.into_bool(ctx);
444    let right = ctx.resolve(right)?.into_bool(ctx);
445    match (left, right) {
446        (
447            CompiledExpr::Constant(ConstantCompiledExpr { value: left }),
448            CompiledExpr::Constant(ConstantCompiledExpr { value: right }),
449        ) => Ok(CompiledExpr::constant(left.to_bool() || right.to_bool())),
450        (CompiledExpr::Constant(ConstantCompiledExpr { value: const_value }), other)
451        | (other, CompiledExpr::Constant(ConstantCompiledExpr { value: const_value })) => {
452            if const_value.to_bool() {
453                Ok(CompiledExpr::constant(true))
454            } else {
455                Ok(other)
456            }
457        }
458        (left, right) => Ok(CompiledExpr::runtime(
459            CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
460            parse_quote! {
461                (#left) || (#right)
462            },
463        )),
464    }
465}
466
467fn resolve_relation(
468    ctx: &Compiler,
469    left: &Expression,
470    op: &RelationOp,
471    right: &Expression,
472) -> Result<CompiledExpr, CompileError> {
473    let left = ctx.resolve(left)?.into_cel()?;
474    let right = ctx.resolve(right)?;
475    if let (
476        RelationOp::In,
477        CompiledExpr::Runtime(RuntimeCompiledExpr {
478            ty:
479                right_ty @ CelType::Proto(ProtoType::Modified(
480                    ProtoModifiedValueType::Repeated(item) | ProtoModifiedValueType::Map(item, _),
481                )),
482            ..
483        }),
484    ) = (op, &right)
485        && !matches!(item, ProtoValueType::Message { .. })
486    {
487        let op = match &right_ty {
488            CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Repeated(_))) => {
489                quote! { array_contains }
490            }
491            CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Map(_, _))) => {
492                quote! { map_contains }
493            }
494            _ => unreachable!(),
495        };
496
497        return Ok(CompiledExpr::runtime(
498            CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
499            parse_quote! {
500                ::tonneau::__private::cel::#op(
501                    #right,
502                    #left,
503                )
504            },
505        ));
506    }
507
508    let right = right.into_cel()?;
509
510    match (left, right) {
511        (
512            CompiledExpr::Constant(ConstantCompiledExpr { value: left }),
513            CompiledExpr::Constant(ConstantCompiledExpr { value: right }),
514        ) => match op {
515            RelationOp::LessThan => Ok(CompiledExpr::constant(CelValue::cel_lt(left, right)?)),
516            RelationOp::LessThanEq => Ok(CompiledExpr::constant(CelValue::cel_lte(left, right)?)),
517            RelationOp::GreaterThan => Ok(CompiledExpr::constant(CelValue::cel_gt(left, right)?)),
518            RelationOp::GreaterThanEq => {
519                Ok(CompiledExpr::constant(CelValue::cel_gte(left, right)?))
520            }
521            RelationOp::Equals => Ok(CompiledExpr::constant(CelValue::cel_eq(left, right)?)),
522            RelationOp::NotEquals => Ok(CompiledExpr::constant(CelValue::cel_neq(left, right)?)),
523            RelationOp::In => Ok(CompiledExpr::constant(CelValue::cel_in(left, right)?)),
524        },
525        (left, right) => {
526            let op = match op {
527                RelationOp::LessThan => quote! { cel_lt },
528                RelationOp::LessThanEq => quote! { cel_lte },
529                RelationOp::GreaterThan => quote! { cel_gt },
530                RelationOp::GreaterThanEq => quote! { cel_gte },
531                RelationOp::Equals => quote! { cel_eq },
532                RelationOp::NotEquals => quote! { cel_neq },
533                RelationOp::In => quote! { cel_in },
534            };
535
536            Ok(CompiledExpr::runtime(
537                CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
538                parse_quote! {
539                    ::tonneau::__private::cel::CelValue::#op(
540                        #left,
541                        #right,
542                    )?
543                },
544            ))
545        }
546    }
547}
548
549fn resolve_ternary(
550    ctx: &Compiler,
551    cond: &Expression,
552    left: &Expression,
553    right: &Expression,
554) -> Result<CompiledExpr, CompileError> {
555    let cond = ctx.resolve(cond)?.into_bool(ctx);
556    let left = ctx.resolve(left)?.into_cel()?;
557    let right = ctx.resolve(right)?.into_cel()?;
558
559    match cond {
560        CompiledExpr::Constant(ConstantCompiledExpr { value: cond }) => {
561            if cond.to_bool() {
562                Ok(left)
563            } else {
564                Ok(right)
565            }
566        }
567        cond => Ok(CompiledExpr::runtime(
568            CelType::CelValue,
569            parse_quote! {
570                if (#cond) {
571                    #left
572                } else {
573                    #right
574                }
575            },
576        )),
577    }
578}
579
580fn resolve_unary(
581    ctx: &Compiler,
582    op: &cel_parser::UnaryOp,
583    expr: &Expression,
584) -> Result<CompiledExpr, CompileError> {
585    let expr = ctx.resolve(expr)?;
586    match op {
587        cel_parser::UnaryOp::Not => {
588            let expr = expr.into_bool(ctx);
589            match expr {
590                CompiledExpr::Constant(ConstantCompiledExpr { value: expr }) => {
591                    Ok(CompiledExpr::constant(!expr.to_bool()))
592                }
593                expr => Ok(CompiledExpr::runtime(
594                    CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
595                    parse_quote! {
596                        !(::tonneau::__private::cel::to_bool(#expr))
597                    },
598                )),
599            }
600        }
601        cel_parser::UnaryOp::DoubleNot => Ok(expr.into_bool(ctx)),
602        cel_parser::UnaryOp::Minus => {
603            let expr = expr.into_cel()?;
604            match expr {
605                CompiledExpr::Constant(ConstantCompiledExpr { value: expr }) => {
606                    Ok(CompiledExpr::constant(CelValue::cel_neg(expr)?))
607                }
608                expr => Ok(CompiledExpr::runtime(
609                    CelType::CelValue,
610                    parse_quote! {
611                        ::tonneau::__private::cel::CelValue::cel_neg(#expr)?
612                    },
613                )),
614            }
615        }
616        cel_parser::UnaryOp::DoubleMinus => Ok(expr),
617    }
618}
619
620#[cfg(test)]
621#[cfg(feature = "prost")]
622#[cfg_attr(coverage_nightly, coverage(off))]
623mod tests {
624    use cel_parser::parse as parse_cel;
625
626    use super::*;
627    use crate::extern_paths::ExternPaths;
628    use crate::path_set::PathSet;
629    use crate::types::ProtoTypeRegistry;
630
631    #[test]
632    fn test_resolve_atom_int() {
633        let registry = ProtoTypeRegistry::new(
634            crate::Mode::Prost,
635            ExternPaths::new(crate::Mode::Prost),
636            PathSet::default(),
637        );
638        let compiler = Compiler::new(&registry);
639        let expr = parse_cel("1").unwrap();
640        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
641        Ok(
642            Constant(
643                ConstantCompiledExpr {
644                    value: Number(
645                        I64(
646                            1,
647                        ),
648                    ),
649                },
650            ),
651        )
652        ");
653    }
654
655    #[test]
656    fn test_resolve_atom_uint() {
657        let registry = ProtoTypeRegistry::new(
658            crate::Mode::Prost,
659            ExternPaths::new(crate::Mode::Prost),
660            PathSet::default(),
661        );
662        let compiler = Compiler::new(&registry);
663        let expr = parse_cel("3u").unwrap();
664        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
665        Ok(
666            Constant(
667                ConstantCompiledExpr {
668                    value: Number(
669                        U64(
670                            3,
671                        ),
672                    ),
673                },
674            ),
675        )
676        ");
677    }
678
679    #[test]
680    fn test_resolve_atom_float() {
681        let registry = ProtoTypeRegistry::new(
682            crate::Mode::Prost,
683            ExternPaths::new(crate::Mode::Prost),
684            PathSet::default(),
685        );
686        let compiler = Compiler::new(&registry);
687        let expr = parse_cel("1.23").unwrap();
688        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
689        Ok(
690            Constant(
691                ConstantCompiledExpr {
692                    value: Number(
693                        F64(
694                            1.23,
695                        ),
696                    ),
697                },
698            ),
699        )
700        ");
701    }
702
703    #[test]
704    fn test_resolve_atom_string_bytes_bool_null() {
705        let registry = ProtoTypeRegistry::new(
706            crate::Mode::Prost,
707            ExternPaths::new(crate::Mode::Prost),
708            PathSet::default(),
709        );
710        let compiler = Compiler::new(&registry);
711
712        let expr_str = parse_cel("\"foo\"").unwrap();
713        insta::assert_debug_snapshot!(resolve(&compiler, &expr_str), @r#"
714        Ok(
715            Constant(
716                ConstantCompiledExpr {
717                    value: String(
718                        Owned(
719                            "foo",
720                        ),
721                    ),
722                },
723            ),
724        )
725        "#);
726
727        let expr_bytes = parse_cel("b\"hi\"").unwrap();
728        insta::assert_debug_snapshot!(resolve(&compiler, &expr_bytes), @r#"
729        Ok(
730            Constant(
731                ConstantCompiledExpr {
732                    value: Bytes(
733                        Owned(
734                            b"hi",
735                        ),
736                    ),
737                },
738            ),
739        )
740        "#);
741
742        let expr_bool = parse_cel("true").unwrap();
743        insta::assert_debug_snapshot!(resolve(&compiler, &expr_bool), @r"
744        Ok(
745            Constant(
746                ConstantCompiledExpr {
747                    value: Bool(
748                        true,
749                    ),
750                },
751            ),
752        )
753        ");
754
755        let expr_null = parse_cel("null").unwrap();
756        insta::assert_debug_snapshot!(resolve(&compiler, &expr_null), @r"
757        Ok(
758            Constant(
759                ConstantCompiledExpr {
760                    value: Null,
761                },
762            ),
763        )
764        ");
765    }
766
767    #[test]
768    fn test_resolve_arithmetic_constant() {
769        let registry = ProtoTypeRegistry::new(
770            crate::Mode::Prost,
771            ExternPaths::new(crate::Mode::Prost),
772            PathSet::default(),
773        );
774        let compiler = Compiler::new(&registry);
775
776        let expr = parse_cel("10 + 5").unwrap();
777        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
778        Ok(
779            Constant(
780                ConstantCompiledExpr {
781                    value: Number(
782                        I64(
783                            15,
784                        ),
785                    ),
786                },
787            ),
788        )
789        ");
790
791        let expr = parse_cel("10 - 4").unwrap();
792        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
793        Ok(
794            Constant(
795                ConstantCompiledExpr {
796                    value: Number(
797                        I64(
798                            6,
799                        ),
800                    ),
801                },
802            ),
803        )
804        ");
805
806        let expr = parse_cel("6 * 7").unwrap();
807        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
808        Ok(
809            Constant(
810                ConstantCompiledExpr {
811                    value: Number(
812                        I64(
813                            42,
814                        ),
815                    ),
816                },
817            ),
818        )
819        ");
820
821        let expr = parse_cel("20 / 4").unwrap();
822        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
823        Ok(
824            Constant(
825                ConstantCompiledExpr {
826                    value: Number(
827                        I64(
828                            5,
829                        ),
830                    ),
831                },
832            ),
833        )
834        ");
835
836        let expr = parse_cel("10 % 3").unwrap();
837        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
838        Ok(
839            Constant(
840                ConstantCompiledExpr {
841                    value: Number(
842                        I64(
843                            1,
844                        ),
845                    ),
846                },
847            ),
848        )
849        ");
850    }
851
852    #[test]
853    fn test_resolve_relation_constant() {
854        let registry = ProtoTypeRegistry::new(
855            crate::Mode::Prost,
856            ExternPaths::new(crate::Mode::Prost),
857            PathSet::default(),
858        );
859        let compiler = Compiler::new(&registry);
860
861        let expr = parse_cel("1 < 2").unwrap();
862        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
863        Ok(
864            Constant(
865                ConstantCompiledExpr {
866                    value: Bool(
867                        true,
868                    ),
869                },
870            ),
871        )
872        ");
873        let expr = parse_cel("1 <= 1").unwrap();
874        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
875        Ok(
876            Constant(
877                ConstantCompiledExpr {
878                    value: Bool(
879                        true,
880                    ),
881                },
882            ),
883        )
884        ");
885        let expr = parse_cel("2 > 1").unwrap();
886        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
887        Ok(
888            Constant(
889                ConstantCompiledExpr {
890                    value: Bool(
891                        true,
892                    ),
893                },
894            ),
895        )
896        ");
897        let expr = parse_cel("2 >= 2").unwrap();
898        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
899        Ok(
900            Constant(
901                ConstantCompiledExpr {
902                    value: Bool(
903                        true,
904                    ),
905                },
906            ),
907        )
908        ");
909        let expr = parse_cel("1 == 1").unwrap();
910        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
911        Ok(
912            Constant(
913                ConstantCompiledExpr {
914                    value: Bool(
915                        true,
916                    ),
917                },
918            ),
919        )
920        ");
921        let expr = parse_cel("1 != 2").unwrap();
922        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
923        Ok(
924            Constant(
925                ConstantCompiledExpr {
926                    value: Bool(
927                        true,
928                    ),
929                },
930            ),
931        )
932        ");
933        let expr = parse_cel("1 in [1, 2, 3]").unwrap();
934        insta::assert_debug_snapshot!(resolve(&compiler, &expr), @r"
935        Ok(
936            Constant(
937                ConstantCompiledExpr {
938                    value: Bool(
939                        true,
940                    ),
941                },
942            ),
943        )
944        ");
945    }
946
947    #[test]
948    fn test_resolve_boolean_constant() {
949        let registry = ProtoTypeRegistry::new(
950            crate::Mode::Prost,
951            ExternPaths::new(crate::Mode::Prost),
952            PathSet::default(),
953        );
954        let compiler = Compiler::new(&registry);
955
956        let expr_and = parse_cel("true && false").unwrap();
957        insta::assert_debug_snapshot!(resolve(&compiler, &expr_and), @r"
958        Ok(
959            Constant(
960                ConstantCompiledExpr {
961                    value: Bool(
962                        false,
963                    ),
964                },
965            ),
966        )
967        ");
968
969        let expr_or = parse_cel("true || false").unwrap();
970        insta::assert_debug_snapshot!(resolve(&compiler, &expr_or), @r"
971        Ok(
972            Constant(
973                ConstantCompiledExpr {
974                    value: Bool(
975                        true,
976                    ),
977                },
978            ),
979        )
980        ");
981    }
982
983    #[test]
984    fn test_resolve_unary_constant() {
985        let registry = ProtoTypeRegistry::new(
986            crate::Mode::Prost,
987            ExternPaths::new(crate::Mode::Prost),
988            PathSet::default(),
989        );
990        let compiler = Compiler::new(&registry);
991
992        let expr_not = parse_cel("!false").unwrap();
993        insta::assert_debug_snapshot!(resolve(&compiler, &expr_not), @r"
994        Ok(
995            Constant(
996                ConstantCompiledExpr {
997                    value: Bool(
998                        true,
999                    ),
1000                },
1001            ),
1002        )
1003        ");
1004
1005        let expr_double_not = parse_cel("!!true").unwrap();
1006        insta::assert_debug_snapshot!(resolve(&compiler, &expr_double_not), @r"
1007        Ok(
1008            Constant(
1009                ConstantCompiledExpr {
1010                    value: Bool(
1011                        true,
1012                    ),
1013                },
1014            ),
1015        )
1016        ");
1017
1018        let expr_neg = parse_cel("-5").unwrap();
1019        insta::assert_debug_snapshot!(resolve(&compiler, &expr_neg), @r"
1020        Ok(
1021            Constant(
1022                ConstantCompiledExpr {
1023                    value: Number(
1024                        I64(
1025                            -5,
1026                        ),
1027                    ),
1028                },
1029            ),
1030        )
1031        ");
1032
1033        let expr_double_neg = parse_cel("--5").unwrap();
1034        insta::assert_debug_snapshot!(resolve(&compiler, &expr_double_neg), @r"
1035        Ok(
1036            Constant(
1037                ConstantCompiledExpr {
1038                    value: Number(
1039                        I64(
1040                            5,
1041                        ),
1042                    ),
1043                },
1044            ),
1045        )
1046        ");
1047    }
1048
1049    #[test]
1050    fn test_resolve_ternary_constant() {
1051        let registry = ProtoTypeRegistry::new(
1052            crate::Mode::Prost,
1053            ExternPaths::new(crate::Mode::Prost),
1054            PathSet::default(),
1055        );
1056        let compiler = Compiler::new(&registry);
1057
1058        let expr_true = parse_cel("true ? 1 : 2").unwrap();
1059        insta::assert_debug_snapshot!(resolve(&compiler, &expr_true), @r"
1060        Ok(
1061            Constant(
1062                ConstantCompiledExpr {
1063                    value: Number(
1064                        I64(
1065                            1,
1066                        ),
1067                    ),
1068                },
1069            ),
1070        )
1071        ");
1072
1073        let expr_false = parse_cel("false ? 1 : 2").unwrap();
1074        insta::assert_debug_snapshot!(resolve(&compiler, &expr_false), @r"
1075        Ok(
1076            Constant(
1077                ConstantCompiledExpr {
1078                    value: Number(
1079                        I64(
1080                            2,
1081                        ),
1082                    ),
1083                },
1084            ),
1085        )
1086        ");
1087    }
1088
1089    #[test]
1090    fn test_resolve_list_map_constant() {
1091        let registry = ProtoTypeRegistry::new(
1092            crate::Mode::Prost,
1093            ExternPaths::new(crate::Mode::Prost),
1094            PathSet::default(),
1095        );
1096        let compiler = Compiler::new(&registry);
1097
1098        let expr_list = parse_cel("[1, 2, 3]").unwrap();
1099        insta::assert_debug_snapshot!(resolve(&compiler, &expr_list), @r"
1100        Ok(
1101            Constant(
1102                ConstantCompiledExpr {
1103                    value: List(
1104                        [
1105                            Number(
1106                                I64(
1107                                    1,
1108                                ),
1109                            ),
1110                            Number(
1111                                I64(
1112                                    2,
1113                                ),
1114                            ),
1115                            Number(
1116                                I64(
1117                                    3,
1118                                ),
1119                            ),
1120                        ],
1121                    ),
1122                },
1123            ),
1124        )
1125        ");
1126
1127        let expr_map = parse_cel("{'a': 1, 'b': 2}").unwrap();
1128        insta::assert_debug_snapshot!(resolve(&compiler, &expr_map), @r#"
1129        Ok(
1130            Constant(
1131                ConstantCompiledExpr {
1132                    value: Map(
1133                        [
1134                            (
1135                                String(
1136                                    Owned(
1137                                        "a",
1138                                    ),
1139                                ),
1140                                Number(
1141                                    I64(
1142                                        1,
1143                                    ),
1144                                ),
1145                            ),
1146                            (
1147                                String(
1148                                    Owned(
1149                                        "b",
1150                                    ),
1151                                ),
1152                                Number(
1153                                    I64(
1154                                        2,
1155                                    ),
1156                                ),
1157                            ),
1158                        ],
1159                    ),
1160                },
1161            ),
1162        )
1163        "#);
1164    }
1165
1166    #[test]
1167    fn test_resolve_negative_variable() {
1168        let registry = ProtoTypeRegistry::new(
1169            crate::Mode::Prost,
1170            ExternPaths::new(crate::Mode::Prost),
1171            PathSet::default(),
1172        );
1173        let mut compiler = Compiler::new(&registry);
1174
1175        compiler.add_variable("x", CompiledExpr::constant(CelValue::Number(1.into())));
1176
1177        let expr_list = parse_cel("-x").unwrap();
1178        insta::assert_debug_snapshot!(resolve(&compiler, &expr_list), @r"
1179        Ok(
1180            Constant(
1181                ConstantCompiledExpr {
1182                    value: Number(
1183                        I64(
1184                            -1,
1185                        ),
1186                    ),
1187                },
1188            ),
1189        )
1190        ");
1191    }
1192
1193    #[test]
1194    fn test_resolve_access() {
1195        let registry = ProtoTypeRegistry::new(
1196            crate::Mode::Prost,
1197            ExternPaths::new(crate::Mode::Prost),
1198            PathSet::default(),
1199        );
1200        let compiler = Compiler::new(&registry);
1201
1202        let expr_list = parse_cel("[1, 2, 3][2]").unwrap();
1203        insta::assert_debug_snapshot!(resolve(&compiler, &expr_list), @r"
1204        Ok(
1205            Constant(
1206                ConstantCompiledExpr {
1207                    value: Number(
1208                        I64(
1209                            3,
1210                        ),
1211                    ),
1212                },
1213            ),
1214        )
1215        ");
1216
1217        let expr_map = parse_cel("({'a': 1, 'b': 2}).a").unwrap();
1218        insta::assert_debug_snapshot!(resolve(&compiler, &expr_map), @r"
1219        Ok(
1220            Constant(
1221                ConstantCompiledExpr {
1222                    value: Number(
1223                        I64(
1224                            1,
1225                        ),
1226                    ),
1227                },
1228            ),
1229        )
1230        ");
1231
1232        let expr_map = parse_cel("({'a': 1, 'b': 2})['b']").unwrap();
1233        insta::assert_debug_snapshot!(resolve(&compiler, &expr_map), @r"
1234        Ok(
1235            Constant(
1236                ConstantCompiledExpr {
1237                    value: Number(
1238                        I64(
1239                            2,
1240                        ),
1241                    ),
1242                },
1243            ),
1244        )
1245        ");
1246    }
1247}