Skip to main content

tonneau_build/codegen/cel/compiler/
helpers.rs

1use syn::parse_quote;
2use tonneau_cel::CelValue;
3
4use super::{CompileError, CompiledExpr, Compiler, ConstantCompiledExpr, RuntimeCompiledExpr};
5use crate::codegen::cel::types::CelType;
6use crate::types::{ProtoModifiedValueType, ProtoType, ProtoValueType, ProtoWellKnownType};
7
8impl CompiledExpr {
9    pub(crate) fn into_bool(self, compiler: &Compiler) -> CompiledExpr {
10        match &self {
11            CompiledExpr::Runtime(RuntimeCompiledExpr {
12                expr,
13                ty: CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::OneOf(_))),
14            }) => CompiledExpr::Runtime(RuntimeCompiledExpr {
15                expr: parse_quote! { (#expr).is_some() },
16                ty: CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
17            }),
18            CompiledExpr::Runtime(RuntimeCompiledExpr {
19                expr,
20                ty: CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Optional(ty))),
21            }) => {
22                let value_to_bool = CompiledExpr::Runtime(RuntimeCompiledExpr {
23                    expr: parse_quote! { ___to_bool_value },
24                    ty: CelType::Proto(ProtoType::Value(ty.clone())),
25                })
26                .into_bool(compiler);
27
28                CompiledExpr::Runtime(RuntimeCompiledExpr {
29                    expr: parse_quote! {
30                        match #expr {
31                            Some(___to_bool_value) => #value_to_bool,
32                            None => false,
33                        }
34                    },
35                    ty: CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
36                })
37            }
38            CompiledExpr::Runtime(RuntimeCompiledExpr {
39                ty: CelType::Proto(ProtoType::Value(ProtoValueType::Message { .. })),
40                ..
41            }) => CompiledExpr::Constant(ConstantCompiledExpr {
42                value: tonneau_cel::CelValue::Bool(true),
43            }),
44            CompiledExpr::Runtime(RuntimeCompiledExpr { expr, .. }) => {
45                CompiledExpr::Runtime(RuntimeCompiledExpr {
46                    expr: parse_quote! {
47                        ::tonneau::__private::cel::to_bool(#expr)
48                    },
49                    ty: CelType::Proto(ProtoType::Value(ProtoValueType::Bool)),
50                })
51            }
52            CompiledExpr::Constant(ConstantCompiledExpr {
53                value: CelValue::Enum(cel_enum),
54            }) => CompiledExpr::Constant(ConstantCompiledExpr {
55                value: tonneau_cel::CelValue::Bool(
56                    compiler
57                        .registry
58                        .get_enum(&cel_enum.tag)
59                        .is_some_and(|e| e.variants.values().any(|v| v.value == cel_enum.value)),
60                ),
61            }),
62            CompiledExpr::Constant(ConstantCompiledExpr { value }) => {
63                CompiledExpr::Constant(ConstantCompiledExpr {
64                    value: tonneau_cel::CelValue::Bool(value.to_bool()),
65                })
66            }
67        }
68    }
69
70    pub(crate) fn into_cel(self) -> Result<CompiledExpr, CompileError> {
71        match self {
72            CompiledExpr::Runtime(RuntimeCompiledExpr {
73                expr,
74                ty: ty @ CelType::CelValue,
75            }) => Ok(CompiledExpr::Runtime(RuntimeCompiledExpr { expr, ty })),
76            CompiledExpr::Runtime(RuntimeCompiledExpr {
77                expr,
78                ty:
79                    CelType::Proto(ProtoType::Value(
80                        ProtoValueType::Bool
81                        | ProtoValueType::Bytes
82                        | ProtoValueType::Double
83                        | ProtoValueType::Float
84                        | ProtoValueType::Int32
85                        | ProtoValueType::Int64
86                        | ProtoValueType::String
87                        | ProtoValueType::UInt32
88                        | ProtoValueType::UInt64
89                        | ProtoValueType::WellKnown(
90                            ProtoWellKnownType::Duration
91                            | ProtoWellKnownType::Empty
92                            | ProtoWellKnownType::ListValue
93                            | ProtoWellKnownType::Struct
94                            | ProtoWellKnownType::Timestamp
95                            | ProtoWellKnownType::Value,
96                        ),
97                    )),
98            }) => Ok(CompiledExpr::Runtime(RuntimeCompiledExpr {
99                expr: parse_quote! {
100                    ::tonneau::__private::cel::CelValueConv::conv(#expr)
101                },
102                ty: CelType::CelValue,
103            })),
104            CompiledExpr::Runtime(RuntimeCompiledExpr {
105                expr,
106                ty:
107                    CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Map(key_ty, value_ty))),
108            }) => {
109                let key_to_cel = CompiledExpr::Runtime(RuntimeCompiledExpr {
110                    expr: parse_quote!(key),
111                    ty: CelType::Proto(ProtoType::Value(key_ty)),
112                })
113                .into_cel()?;
114
115                let value_to_cel = CompiledExpr::Runtime(RuntimeCompiledExpr {
116                    expr: parse_quote!(value),
117                    ty: CelType::Proto(ProtoType::Value(value_ty)),
118                })
119                .into_cel()?;
120
121                Ok(CompiledExpr::Runtime(RuntimeCompiledExpr {
122                    expr: parse_quote! {
123                        ::tonneau::__private::cel::CelValue::Map(
124                            (#expr).into_iter().map(|(key, value)| {
125                                (
126                                    #key_to_cel,
127                                    #value_to_cel,
128                                )
129                            }).collect()
130                        )
131                    },
132                    ty: CelType::CelValue,
133                }))
134            }
135            CompiledExpr::Runtime(RuntimeCompiledExpr {
136                expr,
137                ty: CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Optional(some_ty))),
138            }) => {
139                let some_to_cel = CompiledExpr::Runtime(RuntimeCompiledExpr {
140                    expr: parse_quote!(item),
141                    ty: CelType::Proto(ProtoType::Value(some_ty)),
142                })
143                .into_cel()?;
144
145                Ok(CompiledExpr::Runtime(RuntimeCompiledExpr {
146                    expr: parse_quote! {{
147                        match (#expr) {
148                            ::core::option::Option::Some(item) => #some_to_cel,
149                            ::core::option::Option::None => ::tonneau::__private::cel::CelValue::Null,
150                        }
151                    }},
152                    ty: CelType::CelValue,
153                }))
154            }
155            CompiledExpr::Runtime(RuntimeCompiledExpr {
156                expr,
157                ty: CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::Repeated(item_ty))),
158            }) => {
159                let item_to_cel = CompiledExpr::Runtime(RuntimeCompiledExpr {
160                    expr: parse_quote!(item),
161                    ty: CelType::Proto(ProtoType::Value(item_ty)),
162                })
163                .into_cel()?;
164
165                Ok(CompiledExpr::Runtime(RuntimeCompiledExpr {
166                    expr: parse_quote! {
167                        ::tonneau::__private::cel::CelValue::List((#expr).into_iter().map(|item| #item_to_cel).collect())
168                    },
169                    ty: CelType::CelValue,
170                }))
171            }
172            CompiledExpr::Runtime(RuntimeCompiledExpr {
173                expr,
174                ty: CelType::Proto(ProtoType::Value(ProtoValueType::Enum(path))),
175            }) => {
176                let path = path.as_ref();
177                Ok(CompiledExpr::Runtime(RuntimeCompiledExpr {
178                    expr: parse_quote! {
179                        ::tonneau::__private::cel::CelValue::cel_to_enum(
180                            #expr,
181                            #path,
182                        )?
183                    },
184                    ty: CelType::CelValue,
185                }))
186            }
187            // Not sure how to represent oneofs in cel.
188            CompiledExpr::Runtime(RuntimeCompiledExpr {
189                ty: ty @ CelType::Proto(ProtoType::Modified(ProtoModifiedValueType::OneOf(_))),
190                ..
191            }) => Err(CompileError::TypeConversion {
192                ty: Box::new(ty),
193                message: "oneofs cannot be converted into cel types".into(),
194            }),
195            // Nor messages
196            CompiledExpr::Runtime(RuntimeCompiledExpr {
197                ty: ty @ CelType::Proto(ProtoType::Value(ProtoValueType::Message(_))),
198                ..
199            }) => Err(CompileError::TypeConversion {
200                ty: Box::new(ty),
201                message: "message types cannot be converted into cel types".into(),
202            }),
203            // Currently any is not supported.
204            CompiledExpr::Runtime(RuntimeCompiledExpr {
205                ty:
206                    ty @ CelType::Proto(ProtoType::Value(ProtoValueType::WellKnown(
207                        ProtoWellKnownType::Any,
208                    ))),
209                ..
210            }) => Err(CompileError::TypeConversion {
211                ty: Box::new(ty),
212                message: "any cannot be converted into cel types".into(),
213            }),
214            CompiledExpr::Constant(c) => Ok(CompiledExpr::Constant(c)),
215        }
216    }
217}