hcl/expr/
de.rs

1//! Deserialize impls for HCL structure types.
2
3use super::*;
4use crate::de::{EnumAccess, FromStrVisitor, OptionDeserializer, VariantName};
5use crate::Error;
6use serde::de::value::{MapAccessDeserializer, StrDeserializer, StringDeserializer};
7use serde::de::{self, Expected, IntoDeserializer, Unexpected, VariantAccess};
8use serde::{forward_to_deserialize_any, Deserializer};
9
10impl Expression {
11    #[cold]
12    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
13    where
14        E: de::Error,
15    {
16        de::Error::invalid_type(self.unexpected(), exp)
17    }
18
19    #[cold]
20    fn unexpected(&self) -> Unexpected<'_> {
21        match self {
22            Expression::Null => Unexpected::Unit,
23            Expression::Bool(b) => Unexpected::Bool(*b),
24            Expression::Number(n) => n.unexpected(),
25            Expression::String(s) => Unexpected::Str(s),
26            Expression::Array(_) => Unexpected::Seq,
27            Expression::Object(_) => Unexpected::Map,
28            other => Unexpected::Other(other.variant_name()),
29        }
30    }
31}
32
33impl<'de> de::Deserialize<'de> for Expression {
34    #[allow(clippy::too_many_lines)]
35    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
36    where
37        D: de::Deserializer<'de>,
38    {
39        enum Field {
40            Null,
41            Bool,
42            Number,
43            String,
44            Array,
45            Object,
46            TemplateExpr,
47            Variable,
48            Traversal,
49            FuncCall,
50            Parenthesis,
51            Conditional,
52            Operation,
53            ForExpr,
54        }
55
56        struct FieldVisitor;
57
58        impl de::Visitor<'_> for FieldVisitor {
59            type Value = Field;
60
61            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
62                f.write_str("an HCL expression variant identifier")
63            }
64
65            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
66            where
67                E: de::Error,
68            {
69                match value {
70                    0u64 => Ok(Field::Null),
71                    1u64 => Ok(Field::Bool),
72                    2u64 => Ok(Field::Number),
73                    3u64 => Ok(Field::String),
74                    4u64 => Ok(Field::Array),
75                    5u64 => Ok(Field::Object),
76                    6u64 => Ok(Field::TemplateExpr),
77                    7u64 => Ok(Field::Variable),
78                    8u64 => Ok(Field::Traversal),
79                    9u64 => Ok(Field::FuncCall),
80                    10u64 => Ok(Field::Parenthesis),
81                    11u64 => Ok(Field::Conditional),
82                    12u64 => Ok(Field::Operation),
83                    13u64 => Ok(Field::ForExpr),
84                    _ => Err(de::Error::invalid_value(
85                        Unexpected::Unsigned(value),
86                        &"variant index 0 <= i < 14",
87                    )),
88                }
89            }
90
91            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
92            where
93                E: de::Error,
94            {
95                match value {
96                    "Null" => Ok(Field::Null),
97                    "Bool" => Ok(Field::Bool),
98                    "Number" => Ok(Field::Number),
99                    "String" => Ok(Field::String),
100                    "Array" => Ok(Field::Array),
101                    "Object" => Ok(Field::Object),
102                    "TemplateExpr" => Ok(Field::TemplateExpr),
103                    "Variable" => Ok(Field::Variable),
104                    "Traversal" => Ok(Field::Traversal),
105                    "FuncCall" => Ok(Field::FuncCall),
106                    "Parenthesis" => Ok(Field::Parenthesis),
107                    "Conditional" => Ok(Field::Conditional),
108                    "Operation" => Ok(Field::Operation),
109                    "ForExpr" => Ok(Field::ForExpr),
110                    _ => Err(de::Error::unknown_variant(value, VARIANTS)),
111                }
112            }
113
114            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
115            where
116                E: de::Error,
117            {
118                match value {
119                    b"Null" => Ok(Field::Null),
120                    b"Bool" => Ok(Field::Bool),
121                    b"Number" => Ok(Field::Number),
122                    b"String" => Ok(Field::String),
123                    b"Array" => Ok(Field::Array),
124                    b"Object" => Ok(Field::Object),
125                    b"TemplateExpr" => Ok(Field::TemplateExpr),
126                    b"Variable" => Ok(Field::Variable),
127                    b"Traversal" => Ok(Field::Traversal),
128                    b"FuncCall" => Ok(Field::FuncCall),
129                    b"Parenthesis" => Ok(Field::Parenthesis),
130                    b"Conditional" => Ok(Field::Conditional),
131                    b"Operation" => Ok(Field::Operation),
132                    b"ForExpr" => Ok(Field::ForExpr),
133                    _ => {
134                        let value = &String::from_utf8_lossy(value);
135                        Err(de::Error::unknown_variant(value, VARIANTS))
136                    }
137                }
138            }
139        }
140
141        impl<'de> de::Deserialize<'de> for Field {
142            #[inline]
143            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
144            where
145                D: de::Deserializer<'de>,
146            {
147                deserializer.deserialize_identifier(FieldVisitor)
148            }
149        }
150
151        struct ExpressionVisitor;
152
153        impl<'de> de::Visitor<'de> for ExpressionVisitor {
154            type Value = Expression;
155
156            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
157                f.write_str("an HCL expression")
158            }
159
160            fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
161                Ok(Expression::Bool(value))
162            }
163
164            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
165                Ok(Expression::Number(value.into()))
166            }
167
168            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
169                Ok(Expression::Number(value.into()))
170            }
171
172            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> {
173                Ok(Number::from_f64(value).map_or(Expression::Null, Expression::Number))
174            }
175
176            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
177            where
178                E: serde::de::Error,
179            {
180                self.visit_string(value.to_owned())
181            }
182
183            fn visit_string<E>(self, value: String) -> Result<Self::Value, E> {
184                Ok(Expression::String(value))
185            }
186
187            fn visit_none<E>(self) -> Result<Self::Value, E> {
188                Ok(Expression::Null)
189            }
190
191            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
192            where
193                D: serde::Deserializer<'de>,
194            {
195                Deserialize::deserialize(deserializer)
196            }
197
198            fn visit_unit<E>(self) -> Result<Self::Value, E> {
199                Ok(Expression::Null)
200            }
201
202            fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
203            where
204                V: de::SeqAccess<'de>,
205            {
206                let mut vec = Vec::with_capacity(visitor.size_hint().unwrap_or(0));
207
208                while let Some(elem) = visitor.next_element()? {
209                    vec.push(elem);
210                }
211
212                Ok(Expression::Array(vec))
213            }
214
215            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
216            where
217                V: de::MapAccess<'de>,
218            {
219                let mut map = Object::with_capacity(visitor.size_hint().unwrap_or(0));
220
221                while let Some((key, value)) = visitor.next_entry()? {
222                    map.insert(key, value);
223                }
224
225                Ok(Expression::Object(map))
226            }
227
228            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
229            where
230                A: de::EnumAccess<'de>,
231            {
232                match data.variant()? {
233                    (Field::Null, v) => v.unit_variant().map(|()| Expression::Null),
234                    (Field::Bool, v) => v.newtype_variant().map(Expression::Bool),
235                    (Field::Number, v) => v.newtype_variant().map(Expression::Number),
236                    (Field::String, v) => v.newtype_variant().map(Expression::String),
237                    (Field::Array, v) => v.newtype_variant().map(Expression::Array),
238                    (Field::Object, v) => v.newtype_variant().map(Expression::Object),
239                    (Field::TemplateExpr, v) => v.newtype_variant().map(Expression::TemplateExpr),
240                    (Field::Variable, v) => v.newtype_variant().map(Expression::Variable),
241                    (Field::Traversal, v) => v.newtype_variant().map(Expression::Traversal),
242                    (Field::FuncCall, v) => v.newtype_variant().map(Expression::FuncCall),
243                    (Field::Parenthesis, v) => v.newtype_variant().map(Expression::Parenthesis),
244                    (Field::Conditional, v) => v.newtype_variant().map(Expression::Conditional),
245                    (Field::Operation, v) => v.newtype_variant().map(Expression::Operation),
246                    (Field::ForExpr, v) => v.newtype_variant().map(Expression::ForExpr),
247                }
248            }
249        }
250
251        const VARIANTS: &[&str] = &[
252            "Null",
253            "Bool",
254            "Number",
255            "String",
256            "Array",
257            "Object",
258            "TemplateExpr",
259            "Variable",
260            "Traversal",
261            "FuncCall",
262            "Parenthesis",
263            "Conditional",
264            "Operation",
265            "ForExpr",
266        ];
267
268        deserializer.deserialize_enum("$hcl::Expression", VARIANTS, ExpressionVisitor)
269    }
270}
271
272impl IntoDeserializer<'_, Error> for Expression {
273    type Deserializer = Self;
274
275    fn into_deserializer(self) -> Self::Deserializer {
276        self
277    }
278}
279
280macro_rules! impl_deserialize_number {
281    ($($method:ident)*) => {
282        $(
283            fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
284            where
285                V: de::Visitor<'de>,
286            {
287                match self {
288                    Expression::Number(n) => n.deserialize_any(visitor).map_err(de::Error::custom),
289                    _ => Err(self.invalid_type(&visitor)),
290                }
291            }
292        )*
293    };
294}
295
296impl<'de> de::Deserializer<'de> for Expression {
297    type Error = Error;
298
299    impl_deserialize_number! { deserialize_i8 deserialize_i16 deserialize_i32 deserialize_i64 deserialize_i128 }
300    impl_deserialize_number! { deserialize_u8 deserialize_u16 deserialize_u32 deserialize_u64 deserialize_u128 }
301    impl_deserialize_number! { deserialize_f32 deserialize_f64 }
302
303    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
304    where
305        V: de::Visitor<'de>,
306    {
307        match self {
308            Expression::Null => visitor.visit_unit(),
309            Expression::Bool(b) => visitor.visit_bool(b),
310            Expression::Number(v) => v.deserialize_any(visitor).map_err(de::Error::custom),
311            Expression::String(s) => visitor.visit_string(s),
312            Expression::Array(v) => visitor.visit_seq(v.into_deserializer()),
313            Expression::Object(v) => visitor.visit_map(v.into_deserializer()),
314            Expression::TemplateExpr(v) => visitor.visit_string(v.to_string()),
315            Expression::Parenthesis(v) => v.deserialize_any(visitor),
316            other => other.deserialize_string(visitor),
317        }
318    }
319
320    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
321    where
322        V: de::Visitor<'de>,
323    {
324        match self {
325            Expression::Null => visitor.visit_none(),
326            _ => visitor.visit_some(self),
327        }
328    }
329
330    fn deserialize_enum<V>(
331        self,
332        name: &'static str,
333        _variants: &'static [&'static str],
334        visitor: V,
335    ) -> Result<V::Value, Self::Error>
336    where
337        V: de::Visitor<'de>,
338    {
339        if name == "$hcl::Expression" {
340            return visitor.visit_enum(self);
341        }
342
343        match self {
344            Expression::String(v) => visitor.visit_enum(v.into_deserializer()),
345            Expression::Object(v) => {
346                visitor.visit_enum(MapAccessDeserializer::new(v.into_deserializer()))
347            }
348            Expression::Operation(v) => visitor.visit_enum(EnumAccess::new(*v)),
349            Expression::TemplateExpr(v) => visitor.visit_enum(EnumAccess::new(*v)),
350            _ => Err(self.invalid_type(&"string, object, operation or template expression")),
351        }
352    }
353
354    #[inline]
355    fn deserialize_newtype_struct<V>(
356        self,
357        _name: &'static str,
358        visitor: V,
359    ) -> Result<V::Value, Self::Error>
360    where
361        V: de::Visitor<'de>,
362    {
363        visitor.visit_newtype_struct(self)
364    }
365
366    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
367    where
368        V: de::Visitor<'de>,
369    {
370        match self {
371            Expression::Bool(v) => visitor.visit_bool(v),
372            _ => Err(self.invalid_type(&visitor)),
373        }
374    }
375
376    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
377    where
378        V: de::Visitor<'de>,
379    {
380        self.deserialize_string(visitor)
381    }
382
383    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
384    where
385        V: de::Visitor<'de>,
386    {
387        self.deserialize_string(visitor)
388    }
389
390    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
391    where
392        V: de::Visitor<'de>,
393    {
394        match self {
395            Expression::String(v) => visitor.visit_string(v),
396            Expression::TemplateExpr(v) => visitor.visit_string(v.to_string()),
397            other => {
398                let formatted = format::to_interpolated_string(&other)?;
399                visitor.visit_string(formatted)
400            }
401        }
402    }
403
404    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
405    where
406        V: de::Visitor<'de>,
407    {
408        self.deserialize_byte_buf(visitor)
409    }
410
411    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
412    where
413        V: de::Visitor<'de>,
414    {
415        match self {
416            Expression::String(v) => visitor.visit_string(v),
417            Expression::Array(v) => visitor.visit_seq(v.into_deserializer()),
418            _ => Err(self.invalid_type(&visitor)),
419        }
420    }
421
422    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
423    where
424        V: de::Visitor<'de>,
425    {
426        match self {
427            Expression::Null => visitor.visit_unit(),
428            _ => Err(self.invalid_type(&visitor)),
429        }
430    }
431
432    fn deserialize_unit_struct<V>(
433        self,
434        _name: &'static str,
435        visitor: V,
436    ) -> Result<V::Value, Self::Error>
437    where
438        V: de::Visitor<'de>,
439    {
440        self.deserialize_unit(visitor)
441    }
442
443    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
444    where
445        V: de::Visitor<'de>,
446    {
447        match self {
448            Expression::Array(v) => visitor.visit_seq(v.into_deserializer()),
449            _ => Err(self.invalid_type(&visitor)),
450        }
451    }
452
453    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
454    where
455        V: de::Visitor<'de>,
456    {
457        self.deserialize_seq(visitor)
458    }
459
460    fn deserialize_tuple_struct<V>(
461        self,
462        _name: &'static str,
463        _len: usize,
464        visitor: V,
465    ) -> Result<V::Value, Self::Error>
466    where
467        V: de::Visitor<'de>,
468    {
469        self.deserialize_seq(visitor)
470    }
471
472    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
473    where
474        V: de::Visitor<'de>,
475    {
476        match self {
477            Expression::Object(v) => visitor.visit_map(v.into_deserializer()),
478            Expression::Conditional(v) => visitor.visit_map(ConditionalAccess::new(*v)),
479            Expression::FuncCall(v) => visitor.visit_map(FuncCallAccess::new(*v)),
480            Expression::ForExpr(v) => visitor.visit_map(ForExprAccess::new(*v)),
481            Expression::Traversal(v) => visitor.visit_map(TraversalAccess::new(*v)),
482            Expression::Operation(v) => v.deserialize_any(visitor),
483            Expression::TemplateExpr(v) => v.deserialize_any(visitor),
484            _ => Err(self.invalid_type(&visitor)),
485        }
486    }
487
488    fn deserialize_struct<V>(
489        self,
490        _name: &'static str,
491        _fields: &'static [&'static str],
492        visitor: V,
493    ) -> Result<V::Value, Self::Error>
494    where
495        V: de::Visitor<'de>,
496    {
497        match self {
498            Expression::Array(v) => visitor.visit_seq(v.into_deserializer()),
499            other => other.deserialize_map(visitor),
500        }
501    }
502
503    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
504    where
505        V: de::Visitor<'de>,
506    {
507        self.deserialize_string(visitor)
508    }
509
510    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
511    where
512        V: de::Visitor<'de>,
513    {
514        drop(self);
515        visitor.visit_unit()
516    }
517}
518
519impl<'de> de::EnumAccess<'de> for Expression {
520    type Error = Error;
521    type Variant = Self;
522
523    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
524    where
525        T: de::DeserializeSeed<'de>,
526    {
527        let variant_name = self.variant_name();
528
529        seed.deserialize(variant_name.into_deserializer())
530            .map(|variant| (variant, self))
531    }
532}
533
534impl<'de> de::VariantAccess<'de> for Expression {
535    type Error = Error;
536
537    fn unit_variant(self) -> Result<(), Self::Error> {
538        if self == Expression::Null {
539            Ok(())
540        } else {
541            Err(self.invalid_type(&"unit variant"))
542        }
543    }
544
545    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
546    where
547        T: de::DeserializeSeed<'de>,
548    {
549        match self {
550            Expression::Bool(v) => seed.deserialize(v.into_deserializer()),
551            Expression::Number(v) => seed.deserialize(v).map_err(de::Error::custom),
552            Expression::String(v) => seed.deserialize(v.into_deserializer()),
553            Expression::Array(v) => seed.deserialize(v.into_deserializer()),
554            Expression::Object(v) => seed.deserialize(v.into_deserializer()),
555            Expression::TemplateExpr(v) => seed.deserialize(*v),
556            Expression::Variable(v) => seed.deserialize(v.into_deserializer()),
557            Expression::Traversal(v) => seed.deserialize(v.into_deserializer()),
558            Expression::FuncCall(v) => seed.deserialize(v.into_deserializer()),
559            Expression::Parenthesis(v) => seed.deserialize(*v),
560            Expression::Conditional(v) => seed.deserialize(v.into_deserializer()),
561            Expression::Operation(v) => seed.deserialize(*v),
562            Expression::ForExpr(v) => seed.deserialize(v.into_deserializer()),
563            _ => Err(self.invalid_type(&"newtype variant")),
564        }
565    }
566
567    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
568    where
569        V: de::Visitor<'de>,
570    {
571        self.deserialize_seq(visitor)
572    }
573
574    fn struct_variant<V>(
575        self,
576        _fields: &'static [&'static str],
577        visitor: V,
578    ) -> Result<V::Value, Self::Error>
579    where
580        V: de::Visitor<'de>,
581    {
582        self.deserialize_map(visitor)
583    }
584}
585
586pub struct TraversalAccess {
587    expr: Option<Expression>,
588    operators: Option<Vec<TraversalOperator>>,
589}
590
591impl TraversalAccess {
592    fn new(traversal: Traversal) -> Self {
593        TraversalAccess {
594            expr: Some(traversal.expr),
595            operators: Some(traversal.operators),
596        }
597    }
598}
599
600impl<'de> de::MapAccess<'de> for TraversalAccess {
601    type Error = Error;
602
603    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
604    where
605        K: de::DeserializeSeed<'de>,
606    {
607        if self.expr.is_some() {
608            seed.deserialize("expr".into_deserializer()).map(Some)
609        } else if self.operators.is_some() {
610            seed.deserialize("operators".into_deserializer()).map(Some)
611        } else {
612            Ok(None)
613        }
614    }
615
616    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
617    where
618        V: de::DeserializeSeed<'de>,
619    {
620        if let Some(expr) = self.expr.take() {
621            seed.deserialize(expr.into_deserializer())
622        } else if let Some(operators) = self.operators.take() {
623            seed.deserialize(operators.into_deserializer())
624        } else {
625            Err(de::Error::custom("invalid HCL element access"))
626        }
627    }
628}
629
630impl IntoDeserializer<'_, Error> for TraversalOperator {
631    type Deserializer = Self;
632
633    fn into_deserializer(self) -> Self::Deserializer {
634        self
635    }
636}
637
638impl<'de> de::Deserializer<'de> for TraversalOperator {
639    type Error = Error;
640
641    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
642    where
643        V: de::Visitor<'de>,
644    {
645        match self {
646            TraversalOperator::AttrSplat | TraversalOperator::FullSplat => visitor.visit_unit(),
647            TraversalOperator::GetAttr(ident) => visitor.visit_string(ident.into_inner()),
648            TraversalOperator::Index(expr) => expr.deserialize_any(visitor),
649            TraversalOperator::LegacyIndex(index) => visitor.visit_u64(index),
650        }
651    }
652
653    fn deserialize_enum<V>(
654        self,
655        _name: &'static str,
656        _variants: &'static [&'static str],
657        visitor: V,
658    ) -> Result<V::Value, Self::Error>
659    where
660        V: de::Visitor<'de>,
661    {
662        visitor.visit_enum(self)
663    }
664
665    forward_to_deserialize_any! {
666        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
667        string bytes byte_buf option unit unit_struct newtype_struct seq
668        tuple tuple_struct map struct identifier ignored_any
669    }
670}
671
672impl<'de> de::EnumAccess<'de> for TraversalOperator {
673    type Error = Error;
674    type Variant = Self;
675
676    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
677    where
678        T: de::DeserializeSeed<'de>,
679    {
680        let variant_name = self.variant_name();
681
682        seed.deserialize(variant_name.into_deserializer())
683            .map(|variant| (variant, self))
684    }
685}
686
687impl<'de> de::VariantAccess<'de> for TraversalOperator {
688    type Error = Error;
689
690    fn unit_variant(self) -> Result<(), Self::Error> {
691        de::Deserialize::deserialize(self)
692    }
693
694    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
695    where
696        T: de::DeserializeSeed<'de>,
697    {
698        match self {
699            TraversalOperator::Index(expr) => seed.deserialize(expr),
700            TraversalOperator::GetAttr(ident) => seed.deserialize(ident.into_deserializer()),
701            value => seed.deserialize(value),
702        }
703    }
704
705    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
706    where
707        V: de::Visitor<'de>,
708    {
709        self.deserialize_seq(visitor)
710    }
711
712    fn struct_variant<V>(
713        self,
714        _fields: &'static [&'static str],
715        visitor: V,
716    ) -> Result<V::Value, Self::Error>
717    where
718        V: de::Visitor<'de>,
719    {
720        self.deserialize_map(visitor)
721    }
722}
723
724pub struct FuncCallAccess {
725    name: Option<FuncName>,
726    args: Option<Vec<Expression>>,
727    expand_final: Option<bool>,
728}
729
730impl FuncCallAccess {
731    fn new(func_call: FuncCall) -> Self {
732        FuncCallAccess {
733            name: Some(func_call.name),
734            args: Some(func_call.args),
735            expand_final: Some(func_call.expand_final),
736        }
737    }
738}
739
740impl<'de> de::MapAccess<'de> for FuncCallAccess {
741    type Error = Error;
742
743    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
744    where
745        K: de::DeserializeSeed<'de>,
746    {
747        if self.name.is_some() {
748            seed.deserialize("name".into_deserializer()).map(Some)
749        } else if self.args.is_some() {
750            seed.deserialize("args".into_deserializer()).map(Some)
751        } else if self.expand_final.is_some() {
752            seed.deserialize("expand_final".into_deserializer())
753                .map(Some)
754        } else {
755            Ok(None)
756        }
757    }
758
759    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
760    where
761        V: de::DeserializeSeed<'de>,
762    {
763        if let Some(name) = self.name.take() {
764            seed.deserialize(name.into_deserializer())
765        } else if let Some(args) = self.args.take() {
766            seed.deserialize(args.into_deserializer())
767        } else if let Some(expand_final) = self.expand_final.take() {
768            seed.deserialize(expand_final.into_deserializer())
769        } else {
770            Err(de::Error::custom("invalid HCL function call"))
771        }
772    }
773}
774
775pub struct FuncNameAccess {
776    namespace: Option<Vec<Identifier>>,
777    name: Option<Identifier>,
778}
779
780impl FuncNameAccess {
781    fn new(func_name: FuncName) -> Self {
782        FuncNameAccess {
783            namespace: Some(func_name.namespace),
784            name: Some(func_name.name),
785        }
786    }
787}
788
789impl<'de> de::MapAccess<'de> for FuncNameAccess {
790    type Error = Error;
791
792    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
793    where
794        K: de::DeserializeSeed<'de>,
795    {
796        if self.namespace.is_some() {
797            seed.deserialize("namespace".into_deserializer()).map(Some)
798        } else if self.name.is_some() {
799            seed.deserialize("name".into_deserializer()).map(Some)
800        } else {
801            Ok(None)
802        }
803    }
804
805    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
806    where
807        V: de::DeserializeSeed<'de>,
808    {
809        if let Some(namespace) = self.namespace.take() {
810            seed.deserialize(namespace.into_deserializer())
811        } else if let Some(name) = self.name.take() {
812            seed.deserialize(name.into_deserializer())
813        } else {
814            Err(de::Error::custom("invalid HCL function name"))
815        }
816    }
817}
818
819#[allow(clippy::struct_field_names)]
820pub struct ConditionalAccess {
821    cond_expr: Option<Expression>,
822    true_expr: Option<Expression>,
823    false_expr: Option<Expression>,
824}
825
826impl ConditionalAccess {
827    fn new(cond: Conditional) -> Self {
828        ConditionalAccess {
829            cond_expr: Some(cond.cond_expr),
830            true_expr: Some(cond.true_expr),
831            false_expr: Some(cond.false_expr),
832        }
833    }
834}
835
836impl<'de> de::MapAccess<'de> for ConditionalAccess {
837    type Error = Error;
838
839    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
840    where
841        K: de::DeserializeSeed<'de>,
842    {
843        if self.cond_expr.is_some() {
844            seed.deserialize("cond_expr".into_deserializer()).map(Some)
845        } else if self.true_expr.is_some() {
846            seed.deserialize("true_expr".into_deserializer()).map(Some)
847        } else if self.false_expr.is_some() {
848            seed.deserialize("false_expr".into_deserializer()).map(Some)
849        } else {
850            Ok(None)
851        }
852    }
853
854    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
855    where
856        V: de::DeserializeSeed<'de>,
857    {
858        if let Some(cond_expr) = self.cond_expr.take() {
859            seed.deserialize(cond_expr.into_deserializer())
860        } else if let Some(true_expr) = self.true_expr.take() {
861            seed.deserialize(true_expr.into_deserializer())
862        } else if let Some(false_expr) = self.false_expr.take() {
863            seed.deserialize(false_expr.into_deserializer())
864        } else {
865            Err(de::Error::custom("invalid HCL condition"))
866        }
867    }
868}
869
870impl IntoDeserializer<'_, Error> for Operation {
871    type Deserializer = Self;
872
873    fn into_deserializer(self) -> Self::Deserializer {
874        self
875    }
876}
877
878impl<'de> de::Deserializer<'de> for Operation {
879    type Error = Error;
880
881    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
882    where
883        V: de::Visitor<'de>,
884    {
885        match self {
886            Operation::Unary(op) => visitor.visit_map(UnaryOpAccess::new(op)),
887            Operation::Binary(op) => visitor.visit_map(BinaryOpAccess::new(op)),
888        }
889    }
890
891    impl_deserialize_enum!();
892
893    forward_to_deserialize_any! {
894        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
895        string bytes byte_buf option unit unit_struct newtype_struct seq
896        tuple tuple_struct map struct identifier ignored_any
897    }
898}
899
900pub struct UnaryOpAccess {
901    operator: Option<UnaryOperator>,
902    expr: Option<Expression>,
903}
904
905impl UnaryOpAccess {
906    fn new(op: UnaryOp) -> Self {
907        UnaryOpAccess {
908            operator: Some(op.operator),
909            expr: Some(op.expr),
910        }
911    }
912}
913
914impl<'de> de::MapAccess<'de> for UnaryOpAccess {
915    type Error = Error;
916
917    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
918    where
919        K: de::DeserializeSeed<'de>,
920    {
921        if self.operator.is_some() {
922            seed.deserialize("operator".into_deserializer()).map(Some)
923        } else if self.expr.is_some() {
924            seed.deserialize("expr".into_deserializer()).map(Some)
925        } else {
926            Ok(None)
927        }
928    }
929
930    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
931    where
932        V: de::DeserializeSeed<'de>,
933    {
934        if let Some(operator) = self.operator.take() {
935            seed.deserialize(operator.into_deserializer())
936                .map_err(de::Error::custom)
937        } else if let Some(expr) = self.expr.take() {
938            seed.deserialize(expr.into_deserializer())
939        } else {
940            Err(de::Error::custom("invalid HCL unary operation"))
941        }
942    }
943}
944
945pub struct BinaryOpAccess {
946    lhs_expr: Option<Expression>,
947    operator: Option<BinaryOperator>,
948    rhs_expr: Option<Expression>,
949}
950
951impl BinaryOpAccess {
952    fn new(op: BinaryOp) -> Self {
953        BinaryOpAccess {
954            lhs_expr: Some(op.lhs_expr),
955            operator: Some(op.operator),
956            rhs_expr: Some(op.rhs_expr),
957        }
958    }
959}
960
961impl<'de> de::MapAccess<'de> for BinaryOpAccess {
962    type Error = Error;
963
964    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
965    where
966        K: de::DeserializeSeed<'de>,
967    {
968        if self.lhs_expr.is_some() {
969            seed.deserialize("lhs_expr".into_deserializer()).map(Some)
970        } else if self.operator.is_some() {
971            seed.deserialize("operator".into_deserializer()).map(Some)
972        } else if self.rhs_expr.is_some() {
973            seed.deserialize("rhs_expr".into_deserializer()).map(Some)
974        } else {
975            Ok(None)
976        }
977    }
978
979    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
980    where
981        V: de::DeserializeSeed<'de>,
982    {
983        if let Some(lhs_expr) = self.lhs_expr.take() {
984            seed.deserialize(lhs_expr.into_deserializer())
985        } else if let Some(operator) = self.operator.take() {
986            seed.deserialize(operator.into_deserializer())
987                .map_err(de::Error::custom)
988        } else if let Some(rhs_expr) = self.rhs_expr.take() {
989            seed.deserialize(rhs_expr.into_deserializer())
990        } else {
991            Err(de::Error::custom("invalid HCL binary operation"))
992        }
993    }
994}
995
996pub struct ForExprAccess {
997    key_var: Option<Option<Identifier>>,
998    value_var: Option<Identifier>,
999    collection_expr: Option<Expression>,
1000    key_expr: Option<Option<Expression>>,
1001    value_expr: Option<Expression>,
1002    grouping: Option<bool>,
1003    cond_expr: Option<Option<Expression>>,
1004}
1005
1006impl ForExprAccess {
1007    fn new(expr: ForExpr) -> Self {
1008        ForExprAccess {
1009            key_var: Some(expr.key_var),
1010            value_var: Some(expr.value_var),
1011            collection_expr: Some(expr.collection_expr),
1012            key_expr: Some(expr.key_expr),
1013            value_expr: Some(expr.value_expr),
1014            grouping: Some(expr.grouping),
1015            cond_expr: Some(expr.cond_expr),
1016        }
1017    }
1018}
1019
1020impl<'de> de::MapAccess<'de> for ForExprAccess {
1021    type Error = Error;
1022
1023    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
1024    where
1025        K: de::DeserializeSeed<'de>,
1026    {
1027        if self.key_var.is_some() {
1028            seed.deserialize("key_var".into_deserializer()).map(Some)
1029        } else if self.value_var.is_some() {
1030            seed.deserialize("value_var".into_deserializer()).map(Some)
1031        } else if self.collection_expr.is_some() {
1032            seed.deserialize("collection_expr".into_deserializer())
1033                .map(Some)
1034        } else if self.key_expr.is_some() {
1035            seed.deserialize("key_expr".into_deserializer()).map(Some)
1036        } else if self.value_expr.is_some() {
1037            seed.deserialize("value_expr".into_deserializer()).map(Some)
1038        } else if self.grouping.is_some() {
1039            seed.deserialize("grouping".into_deserializer()).map(Some)
1040        } else if self.cond_expr.is_some() {
1041            seed.deserialize("cond_expr".into_deserializer()).map(Some)
1042        } else {
1043            Ok(None)
1044        }
1045    }
1046
1047    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
1048    where
1049        V: de::DeserializeSeed<'de>,
1050    {
1051        if let Some(key_var) = self.key_var.take() {
1052            seed.deserialize(OptionDeserializer::new(key_var))
1053        } else if let Some(value_var) = self.value_var.take() {
1054            seed.deserialize(value_var.into_deserializer())
1055        } else if let Some(collection_expr) = self.collection_expr.take() {
1056            seed.deserialize(collection_expr.into_deserializer())
1057        } else if let Some(key_expr) = self.key_expr.take() {
1058            seed.deserialize(OptionDeserializer::new(key_expr))
1059        } else if let Some(value_expr) = self.value_expr.take() {
1060            seed.deserialize(value_expr.into_deserializer())
1061        } else if let Some(grouping) = self.grouping.take() {
1062            seed.deserialize(grouping.into_deserializer())
1063        } else if let Some(cond_expr) = self.cond_expr.take() {
1064            seed.deserialize(OptionDeserializer::new(cond_expr))
1065        } else {
1066            Err(de::Error::custom("invalid HCL `for` expression"))
1067        }
1068    }
1069}
1070
1071impl IntoDeserializer<'_, Error> for ObjectKey {
1072    type Deserializer = Self;
1073
1074    fn into_deserializer(self) -> Self::Deserializer {
1075        self
1076    }
1077}
1078
1079impl<'de> de::Deserializer<'de> for ObjectKey {
1080    type Error = Error;
1081
1082    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1083    where
1084        V: de::Visitor<'de>,
1085    {
1086        match self {
1087            ObjectKey::Identifier(ident) => visitor.visit_string(ident.into_inner()),
1088            ObjectKey::Expression(expr) => expr.deserialize_any(visitor),
1089        }
1090    }
1091
1092    fn deserialize_enum<V>(
1093        self,
1094        _name: &'static str,
1095        _variants: &'static [&'static str],
1096        visitor: V,
1097    ) -> Result<V::Value, Self::Error>
1098    where
1099        V: de::Visitor<'de>,
1100    {
1101        visitor.visit_enum(self)
1102    }
1103
1104    forward_to_deserialize_any! {
1105        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
1106        string bytes byte_buf option unit unit_struct newtype_struct seq
1107        tuple tuple_struct map struct identifier ignored_any
1108    }
1109}
1110
1111impl<'de> de::EnumAccess<'de> for ObjectKey {
1112    type Error = Error;
1113    type Variant = Self;
1114
1115    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
1116    where
1117        T: de::DeserializeSeed<'de>,
1118    {
1119        let variant_name = self.variant_name();
1120
1121        seed.deserialize(variant_name.into_deserializer())
1122            .map(|variant| (variant, self))
1123    }
1124}
1125
1126impl<'de> de::VariantAccess<'de> for ObjectKey {
1127    type Error = Error;
1128
1129    fn unit_variant(self) -> Result<(), Self::Error> {
1130        de::Deserialize::deserialize(self)
1131    }
1132
1133    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1134    where
1135        T: de::DeserializeSeed<'de>,
1136    {
1137        match self {
1138            ObjectKey::Expression(expr) => seed.deserialize(expr),
1139            value => seed.deserialize(value),
1140        }
1141    }
1142
1143    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1144    where
1145        V: de::Visitor<'de>,
1146    {
1147        self.deserialize_seq(visitor)
1148    }
1149
1150    fn struct_variant<V>(
1151        self,
1152        _fields: &'static [&'static str],
1153        visitor: V,
1154    ) -> Result<V::Value, Self::Error>
1155    where
1156        V: de::Visitor<'de>,
1157    {
1158        self.deserialize_map(visitor)
1159    }
1160}
1161
1162impl IntoDeserializer<'_, Error> for TemplateExpr {
1163    type Deserializer = Self;
1164
1165    fn into_deserializer(self) -> Self::Deserializer {
1166        self
1167    }
1168}
1169
1170impl<'de> de::Deserializer<'de> for TemplateExpr {
1171    type Error = Error;
1172
1173    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1174    where
1175        V: de::Visitor<'de>,
1176    {
1177        match self {
1178            TemplateExpr::QuotedString(string) => visitor.visit_string(string),
1179            TemplateExpr::Heredoc(heredoc) => visitor.visit_map(HeredocAccess::new(heredoc)),
1180        }
1181    }
1182
1183    impl_deserialize_enum!();
1184
1185    forward_to_deserialize_any! {
1186        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
1187        string bytes byte_buf option unit unit_struct newtype_struct seq
1188        tuple tuple_struct map struct identifier ignored_any
1189    }
1190}
1191
1192pub struct HeredocAccess {
1193    delimiter: Option<Identifier>,
1194    template: Option<String>,
1195    strip: Option<HeredocStripMode>,
1196}
1197
1198impl HeredocAccess {
1199    fn new(value: Heredoc) -> Self {
1200        HeredocAccess {
1201            delimiter: Some(value.delimiter),
1202            template: Some(value.template),
1203            strip: Some(value.strip),
1204        }
1205    }
1206}
1207
1208impl<'de> de::MapAccess<'de> for HeredocAccess {
1209    type Error = Error;
1210
1211    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
1212    where
1213        K: de::DeserializeSeed<'de>,
1214    {
1215        if self.delimiter.is_some() {
1216            seed.deserialize("delimiter".into_deserializer()).map(Some)
1217        } else if self.template.is_some() {
1218            seed.deserialize("template".into_deserializer()).map(Some)
1219        } else if self.strip.is_some() {
1220            seed.deserialize("strip".into_deserializer()).map(Some)
1221        } else {
1222            Ok(None)
1223        }
1224    }
1225
1226    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
1227    where
1228        V: de::DeserializeSeed<'de>,
1229    {
1230        if let Some(delimiter) = self.delimiter.take() {
1231            seed.deserialize(delimiter.into_deserializer())
1232        } else if let Some(template) = self.template.take() {
1233            seed.deserialize(template.into_deserializer())
1234        } else if let Some(strip) = self.strip.take() {
1235            seed.deserialize(strip.into_deserializer())
1236        } else {
1237            Err(de::Error::custom("invalid HCL heredoc"))
1238        }
1239    }
1240}
1241
1242impl IntoDeserializer<'_, Error> for Variable {
1243    type Deserializer = StringDeserializer<Error>;
1244
1245    fn into_deserializer(self) -> Self::Deserializer {
1246        self.into_inner().into_deserializer()
1247    }
1248}
1249
1250impl<'de> de::Deserialize<'de> for HeredocStripMode {
1251    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1252    where
1253        D: de::Deserializer<'de>,
1254    {
1255        deserializer.deserialize_any(FromStrVisitor::<Self>::new("a heredoc strip mode"))
1256    }
1257}
1258
1259impl IntoDeserializer<'_, Error> for HeredocStripMode {
1260    type Deserializer = StrDeserializer<'static, Error>;
1261
1262    fn into_deserializer(self) -> Self::Deserializer {
1263        self.as_str().into_deserializer()
1264    }
1265}
1266
1267impl_variant_name! {
1268    Expression => {
1269        Null, Bool, Number, String, Array, Object, TemplateExpr, Variable,
1270        Traversal, FuncCall, Parenthesis, Conditional, Operation, ForExpr
1271    },
1272    ObjectKey => { Identifier, Expression },
1273    Operation => { Unary, Binary },
1274    TemplateExpr => { QuotedString, Heredoc },
1275    TraversalOperator => { AttrSplat, FullSplat, GetAttr, Index, LegacyIndex }
1276}
1277
1278impl_into_map_access_deserializer! {
1279    BinaryOp => BinaryOpAccess,
1280    Conditional => ConditionalAccess,
1281    ForExpr => ForExprAccess,
1282    FuncCall => FuncCallAccess,
1283    FuncName => FuncNameAccess,
1284    Heredoc => HeredocAccess,
1285    Traversal => TraversalAccess,
1286    UnaryOp => UnaryOpAccess
1287}
hcl/expr/de.rs

hcl/expr/
de.rs
