compose_syntax/ast/
map.rs

1use crate::SyntaxNode;
2use crate::ast::Expr;
3use crate::ast::macros::node;
4
5node! {
6    struct MapLiteral
7}
8
9impl<'a> MapLiteral<'a> {
10    pub fn entries(self) -> impl DoubleEndedIterator<Item = MapEntry<'a>> {
11        self.0.children().filter_map(SyntaxNode::cast)
12    }
13}
14
15node! {
16    struct MapEntry
17}
18
19impl<'a> MapEntry<'a> {
20    pub fn key(self) -> Expr<'a> {
21        self.0.cast_first()
22    }
23
24    pub fn value(self) -> Expr<'a> {
25        self.0.cast_last()
26    }
27}
28
29
30#[cfg(test)]
31mod tests {
32    use crate::ast::Str;
33    use crate::assert_ast;
34    use crate::ast::{Ident, Int, MapEntry, MapLiteral};
35
36    #[test]
37    fn test_map_with_identifier_keys() {
38        assert_ast! {
39            "#{ a: 1, b: 2 }",
40            map as MapLiteral {
41                map.entries() => [
42                    entry as MapEntry {
43                        with i: Ident = entry.key() => {
44                            assert_eq!(i.get(), "a");
45                        }
46                        with i: Int = entry.value() => {
47                            assert_eq!(i.get(), 1);
48                        }
49                    }
50                    entry as MapEntry {
51                        with i: Ident = entry.key() => {
52                            assert_eq!(i.get(), "b");
53                        }
54                        with i: Int = entry.value() => {
55                            assert_eq!(i.get(), 2);
56                        }
57                    }
58                ]
59            }
60        }
61    }
62
63    #[test]
64    fn test_map_with_string_keys() {
65        assert_ast! {
66            "#{ \"a\": 1, \"b\": 2 }",
67            map as MapLiteral {
68                map.entries() => [
69                    entry as MapEntry {
70                        with k: Str = entry.key() => {
71                            assert_eq!(k.get(), "a");
72                        }
73                        with v: Int = entry.value() => {
74                            assert_eq!(v.get(), 1);
75                        }
76                    }
77                    entry as MapEntry {
78                        with k: Str = entry.key() => {
79                            assert_eq!(k.get(), "b");
80                        }
81                        with v: Int = entry.value() => {
82                            assert_eq!(v.get(), 2);
83                        }
84                    }
85                ]
86            }
87        }
88    }
89
90    #[test]
91    fn test_map_with_shorthand_keys() {
92        assert_ast! {
93            "#{ a, b, }",
94            map as MapLiteral {
95                map.entries() => [
96                    entry as MapEntry {
97                        with k: Ident = entry.key() => {
98                            assert_eq!(k.get(), "a");
99                        }
100                        with v: Ident = entry.value() => {
101                            assert_eq!(v.get(), "a");
102                        }
103                    }
104                    entry as MapEntry {
105                        with k: Ident = entry.key() => {
106                            assert_eq!(k.get(), "b");
107                        }
108                        with v: Ident = entry.value() => {
109                            assert_eq!(v.get(), "b");
110                        }
111                    }
112                ]
113            }
114        }
115    }
116}
compose_syntax/ast/map.rs

compose_syntax/ast/
map.rs
