Skip to main content

relate_parser/ast/
expr_children.rs

1//! The one edge table of [`Expr`]: its expression children and its
2//! structural (non-expression) children in one visit-ordered enumeration,
3//! in a shared and a mutable spelling generated from a single definition.
4
5use super::{Expr, InterpPart, LabelExpr, MapProjectionItem, PatternPath, Statement};
6
7/// One direct child of an [`Expr`] node, in the table's visit order.
8///
9/// The visit order is part of the contract: a pattern or subquery edge comes
10/// before the node's expression children and a label edge after them, so a
11/// walker that visits edges as they arrive reproduces the documented order
12/// without a second pass.
13#[derive(Debug)]
14pub enum Edge<'a> {
15    /// An expression child: operand, argument, list/map item, CASE arm,
16    /// comprehension or reduce body, subscript part, interpolation embed.
17    Expr(&'a Expr),
18    /// The pattern of a pattern comprehension, pattern predicate or
19    /// `shortestPath()`.
20    Pattern(&'a PatternPath),
21    /// The nested statement of an `EXISTS`/`COUNT`/`COLLECT` subquery.
22    Subquery(&'a Statement),
23    /// The label expression of a `HasLabel`.
24    Label(&'a LabelExpr),
25}
26
27/// Mutable twin of [`Edge`].
28#[derive(Debug)]
29pub enum EdgeMut<'a> {
30    /// See [`Edge::Expr`].
31    Expr(&'a mut Expr),
32    /// See [`Edge::Pattern`].
33    Pattern(&'a mut PatternPath),
34    /// See [`Edge::Subquery`].
35    Subquery(&'a mut Statement),
36    /// See [`Edge::Label`].
37    Label(&'a mut LabelExpr),
38}
39
40/// Expands the one exhaustive `Expr` match into the shared or the mutable
41/// edge enumeration: `$r` is the borrow (`&` or `&mut`), `$iter` the matching
42/// iterator method, `$edge` the output enum (`Edge` or `EdgeMut`), `$f` the
43/// fallible sink. Every edge, expression or structural, is listed once and
44/// in visit order, so the two spellings cannot drift and nothing is dropped.
45macro_rules! edge_table {
46    (@expr $f:ident, $edge:ident, $e:expr) => { $f($edge::Expr($e))? };
47    (@exprs $f:ident, $edge:ident, $e:expr) => {
48        for x in $e {
49            $f($edge::Expr(x))?;
50        }
51    };
52    (@opt $f:ident, $edge:ident, $e:expr) => {
53        if let Some(x) = $e {
54            $f($edge::Expr(x))?;
55        }
56    };
57    ($self:expr, [$($r:tt)+], $iter:ident, $edge:ident, $f:ident) => {
58        match $self {
59            Expr::Literal(_)
60            | Expr::Variable(_)
61            | Expr::Parameter(_)
62            | Expr::OptionValuePlaceholder
63            | Expr::CountStar
64            | Expr::Star => {}
65            Expr::List(items) => edge_table!(@exprs $f, $edge, items.$iter()),
66            Expr::Map(pairs) => {
67                edge_table!(@exprs $f, $edge, pairs.$iter().map(|p| $($r)+ p.value))
68            }
69            Expr::StringInterp(parts) => {
70                for part in parts.$iter() {
71                    match part {
72                        InterpPart::Interp(e) => edge_table!(@expr $f, $edge, $($r)+ **e),
73                        InterpPart::Text(_) => {}
74                    }
75                }
76            }
77            Expr::Property(p) => {
78                edge_table!(@expr $f, $edge, $($r)+ p.expr);
79                edge_table!(@opt $f, $edge, $($r)+ p.key_expr);
80            }
81            Expr::FunctionCall(fc) => edge_table!(@exprs $f, $edge, fc.args.$iter()),
82            Expr::Binary(b) => edge_table!(@exprs $f, $edge, [$($r)+ b.left, $($r)+ b.right]),
83            Expr::Unary(u) => edge_table!(@expr $f, $edge, $($r)+ u.expr),
84            Expr::Comparison(c) => {
85                edge_table!(@exprs $f, $edge, [$($r)+ c.left, $($r)+ c.right])
86            }
87            Expr::In(i) => edge_table!(@exprs $f, $edge, [$($r)+ i.expr, $($r)+ i.list]),
88            Expr::IsNull(x) => edge_table!(@expr $f, $edge, $($r)+ x.expr),
89            Expr::IsType(x) => edge_table!(@expr $f, $edge, $($r)+ x.expr),
90            Expr::IsNormalized(x) => edge_table!(@expr $f, $edge, $($r)+ x.expr),
91            Expr::ChronologicalCompare(c) => {
92                edge_table!(@exprs $f, $edge, [$($r)+ c.left, $($r)+ c.right])
93            }
94            Expr::StringMatch(m) => {
95                edge_table!(@exprs $f, $edge, [$($r)+ m.left, $($r)+ m.right])
96            }
97            Expr::Case(c) => {
98                for w in c.whens.$iter() {
99                    edge_table!(@exprs $f, $edge, [$($r)+ w.condition, $($r)+ w.result]);
100                }
101                edge_table!(@opt $f, $edge, $($r)+ c.else_expr);
102            }
103            Expr::ListComprehension(lc) => {
104                edge_table!(@expr $f, $edge, $($r)+ lc.list_expr);
105                edge_table!(@opt $f, $edge, $($r)+ lc.where_expr);
106                edge_table!(@opt $f, $edge, $($r)+ lc.map_expr);
107            }
108            Expr::MapComprehension(mc) => {
109                edge_table!(@expr $f, $edge, $($r)+ mc.source_expr);
110                edge_table!(@opt $f, $edge, $($r)+ mc.where_expr);
111                edge_table!(@exprs $f, $edge, [$($r)+ mc.key_expr, $($r)+ mc.value_expr]);
112            }
113            Expr::PatternComprehension(pc) => {
114                $f($edge::Pattern($($r)+ pc.pattern))?;
115                edge_table!(@opt $f, $edge, $($r)+ pc.where_expr);
116                edge_table!(@expr $f, $edge, $($r)+ pc.map_expr);
117            }
118            Expr::Reduce(r) => edge_table!(@exprs $f, $edge,
119                [$($r)+ r.init_expr, $($r)+ r.list_expr, $($r)+ r.expression]),
120            Expr::AllReduce(r) => edge_table!(@exprs $f, $edge,
121                [$($r)+ r.init_expr, $($r)+ r.list_expr, $($r)+ r.expression, $($r)+ r.predicate]),
122            Expr::Subscript(s) => {
123                edge_table!(@expr $f, $edge, $($r)+ s.expr);
124                edge_table!(@opt $f, $edge, $($r)+ s.index);
125                edge_table!(@opt $f, $edge, $($r)+ s.from);
126                edge_table!(@opt $f, $edge, $($r)+ s.to);
127            }
128            Expr::Quantifier(q) => {
129                edge_table!(@expr $f, $edge, $($r)+ q.list);
130                edge_table!(@opt $f, $edge, $($r)+ q.predicate);
131            }
132            Expr::HasLabel(h) => {
133                edge_table!(@expr $f, $edge, $($r)+ h.expr);
134                $f($edge::Label($($r)+ h.label_expr))?;
135            }
136            Expr::Paren(inner) => edge_table!(@expr $f, $edge, $($r)+ **inner),
137            Expr::MapProjection(mp) => {
138                edge_table!(@expr $f, $edge, $($r)+ mp.expr);
139                for item in mp.items.$iter() {
140                    match item {
141                        MapProjectionItem::KeyValue(_, v) => edge_table!(@expr $f, $edge, v),
142                        MapProjectionItem::AllProperties
143                        | MapProjectionItem::Property(_)
144                        | MapProjectionItem::Variable(_) => {}
145                    }
146                }
147            }
148            Expr::ExistsSubquery(s) => $f($edge::Subquery($($r)+ s.statement))?,
149            Expr::CountSubquery(s) => $f($edge::Subquery($($r)+ s.statement))?,
150            Expr::CollectSubquery(s) => $f($edge::Subquery($($r)+ s.statement))?,
151            Expr::ShortestPath(s) => $f($edge::Pattern($($r)+ s.pattern))?,
152            Expr::PatternPredicate(p) => $f($edge::Pattern($($r)+ p.pattern))?,
153        }
154    };
155}
156
157impl Expr {
158    /// Feeds every direct child of this node to `f`, in visit order, stopping
159    /// at the first error. The one enumeration of the model's edges: a
160    /// pattern or subquery edge precedes the expression children, a label
161    /// edge follows them, and expression children appear in source order
162    /// (operands, arguments, list/map items, CASE arms, comprehension and
163    /// reduce bodies, subscript parts, interpolation embeds). A walker that
164    /// consumes edges as they arrive needs no allocation and no second pass.
165    /// The underlying match is exhaustive (no catch-all), so a later variant
166    /// fails compilation.
167    pub fn try_for_each_edge<'a, E>(
168        &'a self,
169        mut f: impl FnMut(Edge<'a>) -> Result<(), E>,
170    ) -> Result<(), E> {
171        edge_table!(self, [&], iter, Edge, f);
172        Ok(())
173    }
174
175    /// Mutable twin of [`Self::try_for_each_edge`], generated from the same
176    /// table.
177    pub fn try_for_each_edge_mut<'a, E>(
178        &'a mut self,
179        mut f: impl FnMut(EdgeMut<'a>) -> Result<(), E>,
180    ) -> Result<(), E> {
181        edge_table!(self, [&mut], iter_mut, EdgeMut, f);
182        Ok(())
183    }
184}