1fn rewrite_expression(
2 expr: &Expression,
3 subs: &std::collections::HashMap<String, Expression>,
4) -> Expression {
5 match expr {
6 Expression::Variable(id) => subs.get(&id.name).cloned().unwrap_or_else(|| expr.clone()),
7 Expression::PostIncrement(loc, inner) => {
8 Expression::PostIncrement(*loc, Box::new(rewrite_expression(inner, subs)))
9 }
10 Expression::PostDecrement(loc, inner) => {
11 Expression::PostDecrement(*loc, Box::new(rewrite_expression(inner, subs)))
12 }
13 Expression::New(loc, inner) => Expression::New(*loc, Box::new(rewrite_expression(inner, subs))),
14 Expression::ArraySubscript(loc, inner, index) => Expression::ArraySubscript(
15 *loc,
16 Box::new(rewrite_expression(inner, subs)),
17 index.as_ref().map(|e| Box::new(rewrite_expression(e, subs))),
18 ),
19 Expression::ArraySlice(loc, inner, start, end) => Expression::ArraySlice(
20 *loc,
21 Box::new(rewrite_expression(inner, subs)),
22 start.as_ref().map(|e| Box::new(rewrite_expression(e, subs))),
23 end.as_ref().map(|e| Box::new(rewrite_expression(e, subs))),
24 ),
25 Expression::Parenthesis(loc, inner) => {
26 Expression::Parenthesis(*loc, Box::new(rewrite_expression(inner, subs)))
27 }
28 Expression::MemberAccess(loc, inner, member) => Expression::MemberAccess(
29 *loc,
30 Box::new(rewrite_expression(inner, subs)),
31 member.clone(),
32 ),
33 Expression::FunctionCall(loc, func, args) => Expression::FunctionCall(
34 *loc,
35 Box::new(rewrite_expression(func, subs)),
36 args.iter().map(|a| rewrite_expression(a, subs)).collect(),
37 ),
38 Expression::FunctionCallBlock(loc, func, block) => Expression::FunctionCallBlock(
39 *loc,
40 Box::new(rewrite_expression(func, subs)),
41 Box::new(rewrite_statement(block, subs, None)),
42 ),
43 Expression::NamedFunctionCall(loc, func, args) => {
44 let rewritten_args: Vec<NamedArgument> = args
45 .iter()
46 .map(|arg| NamedArgument {
47 loc: arg.loc,
48 name: arg.name.clone(),
49 expr: rewrite_expression(&arg.expr, subs),
50 })
51 .collect();
52 Expression::NamedFunctionCall(*loc, Box::new(rewrite_expression(func, subs)), rewritten_args)
53 }
54 Expression::Not(loc, inner) => Expression::Not(*loc, Box::new(rewrite_expression(inner, subs))),
55 Expression::BitwiseNot(loc, inner) => {
56 Expression::BitwiseNot(*loc, Box::new(rewrite_expression(inner, subs)))
57 }
58 Expression::Delete(loc, inner) => {
59 Expression::Delete(*loc, Box::new(rewrite_expression(inner, subs)))
60 }
61 Expression::PreIncrement(loc, inner) => {
62 Expression::PreIncrement(*loc, Box::new(rewrite_expression(inner, subs)))
63 }
64 Expression::PreDecrement(loc, inner) => {
65 Expression::PreDecrement(*loc, Box::new(rewrite_expression(inner, subs)))
66 }
67 Expression::UnaryPlus(loc, inner) => {
68 Expression::UnaryPlus(*loc, Box::new(rewrite_expression(inner, subs)))
69 }
70 Expression::Negate(loc, inner) => {
71 Expression::Negate(*loc, Box::new(rewrite_expression(inner, subs)))
72 }
73
74 Expression::Power(loc, a, b) => Expression::Power(
75 *loc,
76 Box::new(rewrite_expression(a, subs)),
77 Box::new(rewrite_expression(b, subs)),
78 ),
79 Expression::Multiply(loc, a, b) => Expression::Multiply(
80 *loc,
81 Box::new(rewrite_expression(a, subs)),
82 Box::new(rewrite_expression(b, subs)),
83 ),
84 Expression::Divide(loc, a, b) => Expression::Divide(
85 *loc,
86 Box::new(rewrite_expression(a, subs)),
87 Box::new(rewrite_expression(b, subs)),
88 ),
89 Expression::Modulo(loc, a, b) => Expression::Modulo(
90 *loc,
91 Box::new(rewrite_expression(a, subs)),
92 Box::new(rewrite_expression(b, subs)),
93 ),
94 Expression::Add(loc, a, b) => Expression::Add(
95 *loc,
96 Box::new(rewrite_expression(a, subs)),
97 Box::new(rewrite_expression(b, subs)),
98 ),
99 Expression::Subtract(loc, a, b) => Expression::Subtract(
100 *loc,
101 Box::new(rewrite_expression(a, subs)),
102 Box::new(rewrite_expression(b, subs)),
103 ),
104 Expression::ShiftLeft(loc, a, b) => Expression::ShiftLeft(
105 *loc,
106 Box::new(rewrite_expression(a, subs)),
107 Box::new(rewrite_expression(b, subs)),
108 ),
109 Expression::ShiftRight(loc, a, b) => Expression::ShiftRight(
110 *loc,
111 Box::new(rewrite_expression(a, subs)),
112 Box::new(rewrite_expression(b, subs)),
113 ),
114 Expression::BitwiseAnd(loc, a, b) => Expression::BitwiseAnd(
115 *loc,
116 Box::new(rewrite_expression(a, subs)),
117 Box::new(rewrite_expression(b, subs)),
118 ),
119 Expression::BitwiseXor(loc, a, b) => Expression::BitwiseXor(
120 *loc,
121 Box::new(rewrite_expression(a, subs)),
122 Box::new(rewrite_expression(b, subs)),
123 ),
124 Expression::BitwiseOr(loc, a, b) => Expression::BitwiseOr(
125 *loc,
126 Box::new(rewrite_expression(a, subs)),
127 Box::new(rewrite_expression(b, subs)),
128 ),
129 Expression::Less(loc, a, b) => Expression::Less(
130 *loc,
131 Box::new(rewrite_expression(a, subs)),
132 Box::new(rewrite_expression(b, subs)),
133 ),
134 Expression::More(loc, a, b) => Expression::More(
135 *loc,
136 Box::new(rewrite_expression(a, subs)),
137 Box::new(rewrite_expression(b, subs)),
138 ),
139 Expression::LessEqual(loc, a, b) => Expression::LessEqual(
140 *loc,
141 Box::new(rewrite_expression(a, subs)),
142 Box::new(rewrite_expression(b, subs)),
143 ),
144 Expression::MoreEqual(loc, a, b) => Expression::MoreEqual(
145 *loc,
146 Box::new(rewrite_expression(a, subs)),
147 Box::new(rewrite_expression(b, subs)),
148 ),
149 Expression::Equal(loc, a, b) => Expression::Equal(
150 *loc,
151 Box::new(rewrite_expression(a, subs)),
152 Box::new(rewrite_expression(b, subs)),
153 ),
154 Expression::NotEqual(loc, a, b) => Expression::NotEqual(
155 *loc,
156 Box::new(rewrite_expression(a, subs)),
157 Box::new(rewrite_expression(b, subs)),
158 ),
159 Expression::And(loc, a, b) => Expression::And(
160 *loc,
161 Box::new(rewrite_expression(a, subs)),
162 Box::new(rewrite_expression(b, subs)),
163 ),
164 Expression::Or(loc, a, b) => Expression::Or(
165 *loc,
166 Box::new(rewrite_expression(a, subs)),
167 Box::new(rewrite_expression(b, subs)),
168 ),
169 Expression::ConditionalOperator(loc, cond, a, b) => Expression::ConditionalOperator(
170 *loc,
171 Box::new(rewrite_expression(cond, subs)),
172 Box::new(rewrite_expression(a, subs)),
173 Box::new(rewrite_expression(b, subs)),
174 ),
175 Expression::Assign(loc, a, b) => Expression::Assign(
176 *loc,
177 Box::new(rewrite_expression(a, subs)),
178 Box::new(rewrite_expression(b, subs)),
179 ),
180 Expression::AssignOr(loc, a, b) => Expression::AssignOr(
181 *loc,
182 Box::new(rewrite_expression(a, subs)),
183 Box::new(rewrite_expression(b, subs)),
184 ),
185 Expression::AssignAnd(loc, a, b) => Expression::AssignAnd(
186 *loc,
187 Box::new(rewrite_expression(a, subs)),
188 Box::new(rewrite_expression(b, subs)),
189 ),
190 Expression::AssignXor(loc, a, b) => Expression::AssignXor(
191 *loc,
192 Box::new(rewrite_expression(a, subs)),
193 Box::new(rewrite_expression(b, subs)),
194 ),
195 Expression::AssignShiftLeft(loc, a, b) => Expression::AssignShiftLeft(
196 *loc,
197 Box::new(rewrite_expression(a, subs)),
198 Box::new(rewrite_expression(b, subs)),
199 ),
200 Expression::AssignShiftRight(loc, a, b) => Expression::AssignShiftRight(
201 *loc,
202 Box::new(rewrite_expression(a, subs)),
203 Box::new(rewrite_expression(b, subs)),
204 ),
205 Expression::AssignAdd(loc, a, b) => Expression::AssignAdd(
206 *loc,
207 Box::new(rewrite_expression(a, subs)),
208 Box::new(rewrite_expression(b, subs)),
209 ),
210 Expression::AssignSubtract(loc, a, b) => Expression::AssignSubtract(
211 *loc,
212 Box::new(rewrite_expression(a, subs)),
213 Box::new(rewrite_expression(b, subs)),
214 ),
215 Expression::AssignMultiply(loc, a, b) => Expression::AssignMultiply(
216 *loc,
217 Box::new(rewrite_expression(a, subs)),
218 Box::new(rewrite_expression(b, subs)),
219 ),
220 Expression::AssignDivide(loc, a, b) => Expression::AssignDivide(
221 *loc,
222 Box::new(rewrite_expression(a, subs)),
223 Box::new(rewrite_expression(b, subs)),
224 ),
225 Expression::AssignModulo(loc, a, b) => Expression::AssignModulo(
226 *loc,
227 Box::new(rewrite_expression(a, subs)),
228 Box::new(rewrite_expression(b, subs)),
229 ),
230
231 Expression::List(loc, params) => Expression::List(
232 *loc,
233 params
234 .iter()
235 .map(|(loc, param)| {
236 (
237 *loc,
238 param.as_ref().map(|p| Parameter {
239 loc: p.loc,
240 annotation: p.annotation.clone(),
241 ty: rewrite_expression(&p.ty, subs),
242 storage: p.storage.clone(),
243 name: p.name.clone(),
244 }),
245 )
246 })
247 .collect(),
248 ),
249 Expression::ArrayLiteral(loc, values) => Expression::ArrayLiteral(
250 *loc,
251 values.iter().map(|v| rewrite_expression(v, subs)).collect(),
252 ),
253
254 Expression::BoolLiteral(_, _)
256 | Expression::NumberLiteral(_, _, _, _)
257 | Expression::RationalNumberLiteral(_, _, _, _, _)
258 | Expression::HexNumberLiteral(_, _, _)
259 | Expression::StringLiteral(_)
260 | Expression::Type(_, _)
261 | Expression::HexLiteral(_)
262 | Expression::AddressLiteral(_, _) => expr.clone(),
263 }
264}