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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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(®istry);
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}