Branch data Line data Source code
1 : : // Copyright (C) 2020-2024 Free Software Foundation, Inc.
2 : :
3 : : // This file is part of GCC.
4 : :
5 : : // GCC is free software; you can redistribute it and/or modify it under
6 : : // the terms of the GNU General Public License as published by the Free
7 : : // Software Foundation; either version 3, or (at your option) any later
8 : : // version.
9 : :
10 : : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : : // for more details.
14 : :
15 : : // You should have received a copy of the GNU General Public License
16 : : // along with GCC; see the file COPYING3. If not see
17 : : // <http://www.gnu.org/licenses/>.
18 : :
19 : : #include "rust-ast-lower-expr.h"
20 : : #include "rust-ast-lower-base.h"
21 : : #include "rust-ast-lower-block.h"
22 : : #include "rust-ast-lower-struct-field-expr.h"
23 : : #include "rust-ast-lower-pattern.h"
24 : : #include "rust-ast-lower-type.h"
25 : : #include "rust-ast.h"
26 : : #include "rust-diagnostics.h"
27 : :
28 : : namespace Rust {
29 : : namespace HIR {
30 : :
31 : 64986 : ASTLoweringExpr::ASTLoweringExpr ()
32 : 64986 : : ASTLoweringBase (), translated (nullptr), translated_array_elems (nullptr),
33 : 64986 : terminated (false)
34 : 64986 : {}
35 : :
36 : : HIR::Expr *
37 : 64986 : ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated)
38 : : {
39 : 64986 : ASTLoweringExpr resolver;
40 : 64986 : expr.accept_vis (resolver);
41 : 64986 : if (resolver.translated == nullptr)
42 : : {
43 : 0 : rust_fatal_error (expr.get_locus (), "Failed to lower expr: [%s]",
44 : 0 : expr.as_string ().c_str ());
45 : : return nullptr;
46 : : }
47 : :
48 : 64986 : resolver.mappings->insert_hir_expr (resolver.translated);
49 : 64986 : resolver.mappings->insert_location (
50 : 64986 : resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
51 : :
52 : 64986 : if (terminated != nullptr)
53 : 15373 : *terminated = resolver.terminated;
54 : :
55 : 64986 : return resolver.translated;
56 : 64986 : }
57 : :
58 : : void
59 : 726 : ASTLoweringExpr::visit (AST::TupleIndexExpr &expr)
60 : : {
61 : 726 : HIR::Expr *tuple_expr
62 : 726 : = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated);
63 : :
64 : 726 : auto crate_num = mappings->get_current_crate ();
65 : 1452 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
66 : 726 : mappings->get_next_hir_id (crate_num),
67 : 726 : UNKNOWN_LOCAL_DEFID);
68 : :
69 : 726 : translated
70 : 726 : = new HIR::TupleIndexExpr (mapping, std::unique_ptr<HIR::Expr> (tuple_expr),
71 : 726 : expr.get_tuple_index (), expr.get_outer_attrs (),
72 : 1452 : expr.get_locus ());
73 : 726 : }
74 : :
75 : : void
76 : 325 : ASTLoweringExpr::visit (AST::TupleExpr &expr)
77 : : {
78 : 325 : std::vector<std::unique_ptr<HIR::Expr> > tuple_elements;
79 : 947 : for (auto &e : expr.get_tuple_elems ())
80 : : {
81 : 622 : HIR::Expr *t = ASTLoweringExpr::translate (*e);
82 : 622 : tuple_elements.push_back (std::unique_ptr<HIR::Expr> (t));
83 : : }
84 : :
85 : 325 : auto crate_num = mappings->get_current_crate ();
86 : 650 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
87 : 325 : mappings->get_next_hir_id (crate_num),
88 : 325 : UNKNOWN_LOCAL_DEFID);
89 : :
90 : 325 : translated
91 : 325 : = new HIR::TupleExpr (std::move (mapping), std::move (tuple_elements),
92 : 650 : expr.get_inner_attrs (), expr.get_outer_attrs (),
93 : 325 : expr.get_locus ());
94 : 325 : }
95 : :
96 : : void
97 : 291 : ASTLoweringExpr::visit (AST::IfExpr &expr)
98 : : {
99 : 291 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
100 : 291 : }
101 : :
102 : : void
103 : 317 : ASTLoweringExpr::visit (AST::IfExprConseqElse &expr)
104 : : {
105 : 317 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
106 : 317 : }
107 : :
108 : : void
109 : 0 : ASTLoweringExpr::visit (AST::IfLetExpr &expr)
110 : : {
111 : 0 : translated = ASTLoweringIfLetBlock::translate (expr);
112 : 0 : }
113 : :
114 : : void
115 : 1 : ASTLoweringExpr::visit (AST::IfLetExprConseqElse &expr)
116 : : {
117 : 1 : translated = ASTLoweringIfLetBlock::translate (expr);
118 : 1 : }
119 : :
120 : : void
121 : 707 : ASTLoweringExpr::visit (AST::BlockExpr &expr)
122 : : {
123 : 707 : translated = ASTLoweringBlock::translate (expr, &terminated);
124 : 707 : }
125 : :
126 : : void
127 : 2479 : ASTLoweringExpr::visit (AST::UnsafeBlockExpr &expr)
128 : : {
129 : 2479 : translated = ASTLoweringBlock::translate (expr, &terminated);
130 : 2479 : }
131 : :
132 : : void
133 : 10088 : ASTLoweringExpr::visit (AST::PathInExpression &expr)
134 : : {
135 : 10088 : translated = ASTLowerPathInExpression::translate (expr);
136 : 10088 : }
137 : :
138 : : void
139 : 80 : ASTLoweringExpr::visit (AST::QualifiedPathInExpression &expr)
140 : : {
141 : 80 : translated = ASTLowerQualPathInExpression::translate (expr);
142 : 80 : }
143 : :
144 : : void
145 : 326 : ASTLoweringExpr::visit (AST::ReturnExpr &expr)
146 : : {
147 : 326 : terminated = true;
148 : 326 : HIR::Expr *return_expr
149 : 326 : = expr.has_returned_expr ()
150 : 326 : ? ASTLoweringExpr::translate (expr.get_returned_expr ())
151 : 326 : : nullptr;
152 : :
153 : 326 : auto crate_num = mappings->get_current_crate ();
154 : 652 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
155 : 326 : mappings->get_next_hir_id (crate_num),
156 : 326 : UNKNOWN_LOCAL_DEFID);
157 : :
158 : 652 : translated = new HIR::ReturnExpr (mapping, expr.get_locus (),
159 : 326 : std::unique_ptr<HIR::Expr> (return_expr));
160 : 326 : }
161 : :
162 : : void
163 : 6770 : ASTLoweringExpr::visit (AST::CallExpr &expr)
164 : : {
165 : 6770 : HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
166 : :
167 : 6770 : auto const &in_params = expr.get_params ();
168 : 6770 : std::vector<std::unique_ptr<HIR::Expr> > params;
169 : 14431 : for (auto ¶m : in_params)
170 : : {
171 : 7661 : auto trans = ASTLoweringExpr::translate (*param);
172 : 7661 : params.push_back (std::unique_ptr<HIR::Expr> (trans));
173 : : }
174 : :
175 : 6770 : auto crate_num = mappings->get_current_crate ();
176 : 6770 : Analysis::NodeMapping mapping (
177 : : crate_num, UNKNOWN_NODEID /* this can map back to the AST*/,
178 : 6770 : mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
179 : :
180 : 6770 : translated = new HIR::CallExpr (mapping, std::unique_ptr<HIR::Expr> (func),
181 : 6770 : std::move (params), expr.get_outer_attrs (),
182 : 13540 : expr.get_locus ());
183 : 6770 : }
184 : :
185 : : void
186 : 1035 : ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
187 : : {
188 : 1035 : HIR::PathExprSegment method_path
189 : 1035 : = lower_path_expr_seg (expr.get_method_name ());
190 : :
191 : 1035 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
192 : :
193 : 1035 : auto const &in_params = expr.get_params ();
194 : 1035 : std::vector<std::unique_ptr<HIR::Expr> > params;
195 : 1499 : for (auto ¶m : in_params)
196 : : {
197 : 464 : auto trans = ASTLoweringExpr::translate (*param);
198 : 464 : params.push_back (std::unique_ptr<HIR::Expr> (trans));
199 : : }
200 : :
201 : 1035 : auto crate_num = mappings->get_current_crate ();
202 : 2070 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
203 : 1035 : mappings->get_next_hir_id (crate_num),
204 : 1035 : UNKNOWN_LOCAL_DEFID);
205 : :
206 : 1035 : translated
207 : 1035 : = new HIR::MethodCallExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
208 : : method_path, std::move (params),
209 : 2070 : expr.get_outer_attrs (), expr.get_locus ());
210 : 1035 : }
211 : :
212 : : void
213 : 1617 : ASTLoweringExpr::visit (AST::AssignmentExpr &expr)
214 : : {
215 : 1617 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
216 : 1617 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
217 : :
218 : 1617 : auto crate_num = mappings->get_current_crate ();
219 : 3234 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
220 : 1617 : mappings->get_next_hir_id (crate_num),
221 : 1617 : UNKNOWN_LOCAL_DEFID);
222 : :
223 : 1617 : translated
224 : 1617 : = new HIR::AssignmentExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
225 : 3234 : std::unique_ptr<HIR::Expr> (rhs),
226 : 1617 : expr.get_locus ());
227 : 1617 : }
228 : :
229 : : void
230 : 13921 : ASTLoweringExpr::visit (AST::IdentifierExpr &expr)
231 : : {
232 : 13921 : auto crate_num = mappings->get_current_crate ();
233 : 27842 : Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (),
234 : 13921 : mappings->get_next_hir_id (crate_num),
235 : 13921 : UNKNOWN_LOCAL_DEFID);
236 : 13921 : Analysis::NodeMapping mapping2 (mapping1);
237 : :
238 : 13921 : HIR::PathIdentSegment ident_seg (expr.get_ident ().as_string ());
239 : 13921 : HIR::PathExprSegment seg (mapping1, ident_seg, expr.get_locus (),
240 : 27842 : HIR::GenericArgs::create_empty ());
241 : 27842 : translated = new HIR::PathInExpression (mapping2, {seg}, expr.get_locus (),
242 : 27842 : false, expr.get_outer_attrs ());
243 : 13921 : }
244 : :
245 : : void
246 : 297 : ASTLoweringExpr::visit (AST::ArrayExpr &expr)
247 : : {
248 : 297 : expr.get_array_elems ()->accept_vis (*this);
249 : 297 : rust_assert (translated_array_elems != nullptr);
250 : 297 : HIR::ArrayElems *elems = translated_array_elems;
251 : :
252 : 297 : auto crate_num = mappings->get_current_crate ();
253 : 594 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
254 : 297 : mappings->get_next_hir_id (crate_num),
255 : 297 : UNKNOWN_LOCAL_DEFID);
256 : :
257 : 297 : translated
258 : 297 : = new HIR::ArrayExpr (mapping, std::unique_ptr<HIR::ArrayElems> (elems),
259 : 594 : expr.get_inner_attrs (), expr.get_outer_attrs (),
260 : 594 : expr.get_locus ());
261 : 297 : }
262 : :
263 : : void
264 : 433 : ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr)
265 : : {
266 : 433 : HIR::Expr *array_expr = ASTLoweringExpr::translate (expr.get_array_expr ());
267 : 433 : HIR::Expr *array_index_expr
268 : 433 : = ASTLoweringExpr::translate (expr.get_index_expr ());
269 : :
270 : 433 : auto crate_num = mappings->get_current_crate ();
271 : 866 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
272 : 433 : mappings->get_next_hir_id (crate_num),
273 : 433 : UNKNOWN_LOCAL_DEFID);
274 : :
275 : 433 : translated
276 : 433 : = new HIR::ArrayIndexExpr (mapping, std::unique_ptr<HIR::Expr> (array_expr),
277 : 866 : std::unique_ptr<HIR::Expr> (array_index_expr),
278 : 866 : expr.get_outer_attrs (), expr.get_locus ());
279 : 433 : }
280 : :
281 : : void
282 : 189 : ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
283 : : {
284 : 189 : std::vector<std::unique_ptr<HIR::Expr> > elements;
285 : 1118 : for (auto &elem : elems.get_values ())
286 : : {
287 : 929 : HIR::Expr *translated_elem = ASTLoweringExpr::translate (*elem);
288 : 929 : elements.push_back (std::unique_ptr<HIR::Expr> (translated_elem));
289 : : }
290 : :
291 : 189 : auto crate_num = mappings->get_current_crate ();
292 : 189 : Analysis::NodeMapping mapping (mappings->get_current_crate (),
293 : : elems.get_node_id (),
294 : 189 : mappings->get_next_hir_id (crate_num),
295 : 189 : UNKNOWN_LOCAL_DEFID);
296 : :
297 : 189 : translated_array_elems
298 : 189 : = new HIR::ArrayElemsValues (mapping, std::move (elements));
299 : 189 : }
300 : :
301 : : void
302 : 108 : ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems)
303 : : {
304 : 108 : HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ());
305 : 108 : HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ());
306 : :
307 : 108 : auto crate_num = mappings->get_current_crate ();
308 : 108 : Analysis::NodeMapping mapping (mappings->get_current_crate (),
309 : : elems.get_node_id (),
310 : 108 : mappings->get_next_hir_id (crate_num),
311 : 108 : UNKNOWN_LOCAL_DEFID);
312 : :
313 : 108 : translated_array_elems
314 : 108 : = new HIR::ArrayElemsCopied (mapping, std::unique_ptr<HIR::Expr> (element),
315 : 108 : std::unique_ptr<HIR::Expr> (num_copies));
316 : 108 : }
317 : :
318 : : void
319 : 13038 : ASTLoweringExpr::visit (AST::LiteralExpr &expr)
320 : : {
321 : 13038 : auto crate_num = mappings->get_current_crate ();
322 : 26076 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
323 : 13038 : mappings->get_next_hir_id (crate_num),
324 : 13038 : UNKNOWN_LOCAL_DEFID);
325 : :
326 : 13038 : HIR::Literal l = lower_literal (expr.get_literal ());
327 : 13038 : translated = new HIR::LiteralExpr (mapping, std::move (l), expr.get_locus (),
328 : 26076 : expr.get_outer_attrs ());
329 : 13038 : }
330 : :
331 : : void
332 : 2433 : ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
333 : : {
334 : 2433 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
335 : 2433 : rust_assert (lhs != nullptr);
336 : 2433 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
337 : 2433 : rust_assert (rhs != nullptr);
338 : :
339 : 2433 : auto crate_num = mappings->get_current_crate ();
340 : 4866 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
341 : 2433 : mappings->get_next_hir_id (crate_num),
342 : 2433 : UNKNOWN_LOCAL_DEFID);
343 : :
344 : 4866 : translated = new HIR::ArithmeticOrLogicalExpr (
345 : 2433 : mapping, std::unique_ptr<HIR::Expr> (lhs), std::unique_ptr<HIR::Expr> (rhs),
346 : 2433 : expr.get_expr_type (), expr.get_locus ());
347 : 2433 : }
348 : :
349 : : void
350 : 900 : ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
351 : : {
352 : 900 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
353 : 900 : rust_assert (lhs != nullptr);
354 : 900 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
355 : 900 : rust_assert (rhs != nullptr);
356 : :
357 : 900 : auto crate_num = mappings->get_current_crate ();
358 : 1800 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
359 : 900 : mappings->get_next_hir_id (crate_num),
360 : 900 : UNKNOWN_LOCAL_DEFID);
361 : :
362 : 900 : translated
363 : 900 : = new HIR::ComparisonExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
364 : 1800 : std::unique_ptr<HIR::Expr> (rhs),
365 : 900 : expr.get_expr_type (), expr.get_locus ());
366 : 900 : }
367 : :
368 : : void
369 : 378 : ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr)
370 : : {
371 : 378 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
372 : 378 : rust_assert (lhs != nullptr);
373 : 378 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
374 : 378 : rust_assert (rhs != nullptr);
375 : :
376 : 378 : auto crate_num = mappings->get_current_crate ();
377 : 756 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
378 : 378 : mappings->get_next_hir_id (crate_num),
379 : 378 : UNKNOWN_LOCAL_DEFID);
380 : :
381 : 378 : translated
382 : 378 : = new HIR::LazyBooleanExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
383 : 756 : std::unique_ptr<HIR::Expr> (rhs),
384 : 378 : expr.get_expr_type (), expr.get_locus ());
385 : 378 : }
386 : :
387 : : void
388 : 290 : ASTLoweringExpr::visit (AST::NegationExpr &expr)
389 : : {
390 : 290 : HIR::Expr *negated_value
391 : 290 : = ASTLoweringExpr::translate (expr.get_negated_expr ());
392 : :
393 : 290 : auto crate_num = mappings->get_current_crate ();
394 : 580 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
395 : 290 : mappings->get_next_hir_id (crate_num),
396 : 290 : UNKNOWN_LOCAL_DEFID);
397 : 290 : translated
398 : 290 : = new HIR::NegationExpr (mapping,
399 : 290 : std::unique_ptr<HIR::Expr> (negated_value),
400 : 290 : expr.get_expr_type (), expr.get_outer_attrs (),
401 : 580 : expr.get_locus ());
402 : 290 : }
403 : :
404 : : void
405 : 3283 : ASTLoweringExpr::visit (AST::TypeCastExpr &expr)
406 : : {
407 : 3283 : HIR::Expr *expr_to_cast_to
408 : 3283 : = ASTLoweringExpr::translate (expr.get_casted_expr ());
409 : 3283 : HIR::Type *type_to_cast_to
410 : 3283 : = lower_type_no_bounds (expr.get_type_to_cast_to ());
411 : :
412 : 3283 : auto crate_num = mappings->get_current_crate ();
413 : 6566 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
414 : 3283 : mappings->get_next_hir_id (crate_num),
415 : 3283 : UNKNOWN_LOCAL_DEFID);
416 : :
417 : 3283 : translated
418 : 3283 : = new HIR::TypeCastExpr (mapping,
419 : 3283 : std::unique_ptr<HIR::Expr> (expr_to_cast_to),
420 : 6566 : std::unique_ptr<HIR::Type> (type_to_cast_to),
421 : 3283 : expr.get_locus ());
422 : 3283 : }
423 : :
424 : : void
425 : 160 : ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr)
426 : : {
427 : 160 : ArithmeticOrLogicalOperator op;
428 : 160 : switch (expr.get_expr_type ())
429 : : {
430 : : case CompoundAssignmentOperator::ADD:
431 : : op = ArithmeticOrLogicalOperator::ADD;
432 : : break;
433 : : case CompoundAssignmentOperator::SUBTRACT:
434 : : op = ArithmeticOrLogicalOperator::SUBTRACT;
435 : : break;
436 : : case CompoundAssignmentOperator::MULTIPLY:
437 : : op = ArithmeticOrLogicalOperator::MULTIPLY;
438 : : break;
439 : : case CompoundAssignmentOperator::DIVIDE:
440 : : op = ArithmeticOrLogicalOperator::DIVIDE;
441 : : break;
442 : : case CompoundAssignmentOperator::MODULUS:
443 : : op = ArithmeticOrLogicalOperator::MODULUS;
444 : : break;
445 : : case CompoundAssignmentOperator::BITWISE_AND:
446 : : op = ArithmeticOrLogicalOperator::BITWISE_AND;
447 : : break;
448 : : case CompoundAssignmentOperator::BITWISE_OR:
449 : : op = ArithmeticOrLogicalOperator::BITWISE_OR;
450 : : break;
451 : : case CompoundAssignmentOperator::BITWISE_XOR:
452 : : op = ArithmeticOrLogicalOperator::BITWISE_XOR;
453 : : break;
454 : : case CompoundAssignmentOperator::LEFT_SHIFT:
455 : : op = ArithmeticOrLogicalOperator::LEFT_SHIFT;
456 : : break;
457 : : case CompoundAssignmentOperator::RIGHT_SHIFT:
458 : : op = ArithmeticOrLogicalOperator::RIGHT_SHIFT;
459 : : break;
460 : 0 : default:
461 : 0 : rust_unreachable ();
462 : : }
463 : :
464 : 160 : HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
465 : 160 : HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
466 : :
467 : 160 : auto crate_num = mappings->get_current_crate ();
468 : 320 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
469 : 160 : mappings->get_next_hir_id (crate_num),
470 : 160 : UNKNOWN_LOCAL_DEFID);
471 : :
472 : 320 : translated = new HIR::CompoundAssignmentExpr (
473 : 160 : mapping, std::unique_ptr<HIR::Expr> (asignee_expr),
474 : 320 : std::unique_ptr<HIR::Expr> (value), op, expr.get_locus ());
475 : 160 : }
476 : :
477 : : void
478 : 51 : ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr)
479 : : {
480 : 51 : HIR::PathInExpression *path
481 : 51 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
482 : 51 : HIR::PathInExpression copied_path (*path);
483 : 51 : delete path;
484 : :
485 : 51 : auto crate_num = mappings->get_current_crate ();
486 : 102 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
487 : 51 : mappings->get_next_hir_id (crate_num),
488 : 51 : UNKNOWN_LOCAL_DEFID);
489 : :
490 : 102 : translated = new HIR::StructExprStruct (mapping, copied_path,
491 : 51 : struct_expr.get_inner_attrs (),
492 : 51 : struct_expr.get_outer_attrs (),
493 : 51 : struct_expr.get_locus ());
494 : 51 : }
495 : :
496 : : void
497 : 811 : ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
498 : : {
499 : : // bit of a hack for now
500 : 811 : HIR::PathInExpression *path
501 : 811 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
502 : 811 : HIR::PathInExpression copied_path (*path);
503 : 811 : delete path;
504 : :
505 : 811 : HIR::StructBase *base = nullptr;
506 : 811 : if (struct_expr.has_struct_base ())
507 : : {
508 : 63 : HIR::Expr *translated_base = ASTLoweringExpr::translate (
509 : 63 : struct_expr.get_struct_base ().get_base_struct ());
510 : 63 : base = new HIR::StructBase (std::unique_ptr<HIR::Expr> (translated_base));
511 : : }
512 : :
513 : 811 : auto const &in_fields = struct_expr.get_fields ();
514 : 811 : std::vector<std::unique_ptr<HIR::StructExprField> > fields;
515 : 2347 : for (auto &field : in_fields)
516 : : {
517 : 1536 : HIR::StructExprField *translated
518 : 1536 : = ASTLowerStructExprField::translate (*field);
519 : 1536 : fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
520 : : }
521 : :
522 : 811 : auto crate_num = mappings->get_current_crate ();
523 : 1622 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
524 : 811 : mappings->get_next_hir_id (crate_num),
525 : 811 : UNKNOWN_LOCAL_DEFID);
526 : :
527 : 811 : translated
528 : 811 : = new HIR::StructExprStructFields (mapping, copied_path, std::move (fields),
529 : : struct_expr.get_locus (), base,
530 : 811 : struct_expr.get_inner_attrs (),
531 : 811 : struct_expr.get_outer_attrs ());
532 : 811 : }
533 : :
534 : : void
535 : 159 : ASTLoweringExpr::visit (AST::GroupedExpr &expr)
536 : : {
537 : 159 : HIR::Expr *paren_expr
538 : 159 : = ASTLoweringExpr::translate (expr.get_expr_in_parens ());
539 : :
540 : 159 : auto crate_num = mappings->get_current_crate ();
541 : 318 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
542 : 159 : mappings->get_next_hir_id (crate_num),
543 : 159 : UNKNOWN_LOCAL_DEFID);
544 : :
545 : 159 : translated
546 : 159 : = new HIR::GroupedExpr (mapping, std::unique_ptr<HIR::Expr> (paren_expr),
547 : 318 : expr.get_inner_attrs (), expr.get_outer_attrs (),
548 : 318 : expr.get_locus ());
549 : 159 : }
550 : :
551 : : void
552 : 1407 : ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
553 : : {
554 : 1407 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
555 : :
556 : 1407 : auto crate_num = mappings->get_current_crate ();
557 : 2814 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
558 : 1407 : mappings->get_next_hir_id (crate_num),
559 : 1407 : UNKNOWN_LOCAL_DEFID);
560 : 1407 : translated
561 : 1407 : = new HIR::FieldAccessExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
562 : 2814 : expr.get_field_name (), expr.get_outer_attrs (),
563 : 2814 : expr.get_locus ());
564 : 1407 : }
565 : :
566 : : void
567 : 90 : ASTLoweringExpr::visit (AST::LoopExpr &expr)
568 : : {
569 : 90 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
570 : 90 : }
571 : :
572 : : void
573 : 35 : ASTLoweringExpr::visit (AST::WhileLoopExpr &expr)
574 : : {
575 : 35 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
576 : 35 : }
577 : :
578 : : void
579 : 0 : ASTLoweringExpr::visit (AST::ForLoopExpr &expr)
580 : : {
581 : 0 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
582 : 0 : }
583 : :
584 : : void
585 : 59 : ASTLoweringExpr::visit (AST::BreakExpr &expr)
586 : : {
587 : 59 : HIR::Lifetime break_label
588 : 59 : = lower_lifetime (expr.get_label ().get_lifetime ());
589 : 59 : HIR::Expr *break_expr
590 : 59 : = expr.has_break_expr ()
591 : 59 : ? ASTLoweringExpr::translate (expr.get_break_expr ())
592 : 59 : : nullptr;
593 : :
594 : 59 : auto crate_num = mappings->get_current_crate ();
595 : 118 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
596 : 59 : mappings->get_next_hir_id (crate_num),
597 : 59 : UNKNOWN_LOCAL_DEFID);
598 : :
599 : 59 : translated
600 : 59 : = new HIR::BreakExpr (mapping, expr.get_locus (), std ::move (break_label),
601 : 59 : std::unique_ptr<HIR::Expr> (break_expr),
602 : 118 : expr.get_outer_attrs ());
603 : 59 : }
604 : :
605 : : void
606 : 9 : ASTLoweringExpr::visit (AST::ContinueExpr &expr)
607 : : {
608 : 9 : HIR::Lifetime break_label = lower_lifetime (expr.get_label ());
609 : :
610 : 9 : auto crate_num = mappings->get_current_crate ();
611 : 18 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
612 : 9 : mappings->get_next_hir_id (crate_num),
613 : 9 : UNKNOWN_LOCAL_DEFID);
614 : :
615 : 9 : translated
616 : 9 : = new HIR::ContinueExpr (mapping, expr.get_locus (),
617 : 18 : std ::move (break_label), expr.get_outer_attrs ());
618 : 9 : }
619 : :
620 : : void
621 : 916 : ASTLoweringExpr::visit (AST::BorrowExpr &expr)
622 : : {
623 : 916 : HIR::Expr *borrow_lvalue
624 : 916 : = ASTLoweringExpr::translate (expr.get_borrowed_expr ());
625 : :
626 : 916 : auto crate_num = mappings->get_current_crate ();
627 : 1832 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
628 : 916 : mappings->get_next_hir_id (crate_num),
629 : 916 : UNKNOWN_LOCAL_DEFID);
630 : :
631 : 916 : auto *borrow_expr
632 : 2748 : = new HIR::BorrowExpr (mapping, std::unique_ptr<HIR::Expr> (borrow_lvalue),
633 : 916 : expr.get_is_mut () ? Mutability::Mut
634 : : : Mutability::Imm,
635 : 1617 : expr.get_outer_attrs (), expr.get_locus ());
636 : :
637 : 916 : if (expr.get_is_double_borrow ())
638 : : {
639 : 23 : NodeId artificial_double_borrow_id = mappings->get_next_node_id ();
640 : 23 : Analysis::NodeMapping mapping (crate_num, artificial_double_borrow_id,
641 : 23 : mappings->get_next_hir_id (crate_num),
642 : 23 : UNKNOWN_LOCAL_DEFID);
643 : :
644 : 23 : borrow_expr
645 : 23 : = new HIR::BorrowExpr (mapping,
646 : 23 : std::unique_ptr<HIR::Expr> (borrow_expr),
647 : 23 : expr.get_is_mut () ? Mutability::Mut
648 : : : Mutability::Imm,
649 : 69 : expr.get_outer_attrs (), expr.get_locus ());
650 : : }
651 : :
652 : 916 : translated = borrow_expr;
653 : 916 : }
654 : :
655 : : void
656 : 1232 : ASTLoweringExpr::visit (AST::DereferenceExpr &expr)
657 : : {
658 : 1232 : HIR::Expr *dref_lvalue
659 : 1232 : = ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
660 : :
661 : 1232 : auto crate_num = mappings->get_current_crate ();
662 : 2464 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
663 : 1232 : mappings->get_next_hir_id (crate_num),
664 : 1232 : UNKNOWN_LOCAL_DEFID);
665 : :
666 : 1232 : translated
667 : 1232 : = new HIR::DereferenceExpr (mapping,
668 : 1232 : std::unique_ptr<HIR::Expr> (dref_lvalue),
669 : 2464 : expr.get_outer_attrs (), expr.get_locus ());
670 : 1232 : }
671 : :
672 : : void
673 : 0 : ASTLoweringExpr::visit (AST::ErrorPropagationExpr &expr)
674 : : {
675 : 0 : HIR::Expr *propagating_expr
676 : 0 : = ASTLoweringExpr::translate (expr.get_propagating_expr ());
677 : :
678 : 0 : auto crate_num = mappings->get_current_crate ();
679 : 0 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
680 : 0 : mappings->get_next_hir_id (crate_num),
681 : 0 : UNKNOWN_LOCAL_DEFID);
682 : 0 : translated = new HIR::ErrorPropagationExpr (
683 : 0 : mapping, std::unique_ptr<HIR::Expr> (propagating_expr),
684 : 0 : expr.get_outer_attrs (), expr.get_locus ());
685 : 0 : }
686 : :
687 : : void
688 : 198 : ASTLoweringExpr::visit (AST::MatchExpr &expr)
689 : : {
690 : 198 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
691 : 198 : }
692 : :
693 : : void
694 : 50 : ASTLoweringExpr::visit (AST::RangeFromToExpr &expr)
695 : : {
696 : 50 : auto crate_num = mappings->get_current_crate ();
697 : 100 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
698 : 50 : mappings->get_next_hir_id (crate_num),
699 : 50 : UNKNOWN_LOCAL_DEFID);
700 : :
701 : 50 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
702 : 50 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
703 : :
704 : 50 : translated
705 : 50 : = new HIR::RangeFromToExpr (mapping,
706 : 50 : std::unique_ptr<HIR::Expr> (range_from),
707 : 100 : std::unique_ptr<HIR::Expr> (range_to),
708 : 50 : expr.get_locus ());
709 : 50 : }
710 : :
711 : : void
712 : 7 : ASTLoweringExpr::visit (AST::RangeFromExpr &expr)
713 : : {
714 : 7 : auto crate_num = mappings->get_current_crate ();
715 : 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
716 : 7 : mappings->get_next_hir_id (crate_num),
717 : 7 : UNKNOWN_LOCAL_DEFID);
718 : :
719 : 7 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
720 : :
721 : 7 : translated
722 : 7 : = new HIR::RangeFromExpr (mapping, std::unique_ptr<HIR::Expr> (range_from),
723 : 7 : expr.get_locus ());
724 : 7 : }
725 : :
726 : : void
727 : 7 : ASTLoweringExpr::visit (AST::RangeToExpr &expr)
728 : : {
729 : 7 : auto crate_num = mappings->get_current_crate ();
730 : 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
731 : 7 : mappings->get_next_hir_id (crate_num),
732 : 7 : UNKNOWN_LOCAL_DEFID);
733 : :
734 : 7 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
735 : :
736 : 7 : translated
737 : 7 : = new HIR::RangeToExpr (mapping, std::unique_ptr<HIR::Expr> (range_to),
738 : 7 : expr.get_locus ());
739 : 7 : }
740 : :
741 : : void
742 : 0 : ASTLoweringExpr::visit (AST::RangeFullExpr &expr)
743 : : {
744 : 0 : auto crate_num = mappings->get_current_crate ();
745 : 0 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
746 : 0 : mappings->get_next_hir_id (crate_num),
747 : 0 : UNKNOWN_LOCAL_DEFID);
748 : :
749 : 0 : translated = new HIR::RangeFullExpr (mapping, expr.get_locus ());
750 : 0 : }
751 : :
752 : : void
753 : 7 : ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr)
754 : : {
755 : 7 : auto crate_num = mappings->get_current_crate ();
756 : 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
757 : 7 : mappings->get_next_hir_id (crate_num),
758 : 7 : UNKNOWN_LOCAL_DEFID);
759 : :
760 : 7 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
761 : 7 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
762 : :
763 : 7 : translated
764 : 7 : = new HIR::RangeFromToInclExpr (mapping,
765 : 7 : std::unique_ptr<HIR::Expr> (range_from),
766 : 14 : std::unique_ptr<HIR::Expr> (range_to),
767 : 7 : expr.get_locus ());
768 : 7 : }
769 : :
770 : : void
771 : 23 : ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
772 : : {
773 : 23 : HIR::Expr *closure_expr
774 : 23 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
775 : :
776 : 23 : std::vector<HIR::ClosureParam> closure_params;
777 : 39 : for (auto ¶m : expr.get_params ())
778 : : {
779 : 16 : HIR::ClosureParam p = lower_closure_param (param);
780 : 16 : closure_params.push_back (std::move (p));
781 : 16 : }
782 : :
783 : 23 : auto crate_num = mappings->get_current_crate ();
784 : 46 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
785 : 23 : mappings->get_next_hir_id (crate_num),
786 : 23 : mappings->get_next_localdef_id (crate_num));
787 : :
788 : 23 : translated
789 : 23 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
790 : : nullptr /* closure_return_type */,
791 : 23 : std::unique_ptr<HIR::Expr> (closure_expr),
792 : 46 : expr.get_has_move (), expr.get_outer_attrs (),
793 : 23 : expr.get_locus ());
794 : 23 : }
795 : :
796 : : void
797 : 30 : ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
798 : : {
799 : 30 : HIR::Type *closure_return_type = nullptr;
800 : 30 : HIR::Expr *closure_expr
801 : 30 : = ASTLoweringExpr::translate (expr.get_definition_block ());
802 : :
803 : 30 : std::vector<HIR::ClosureParam> closure_params;
804 : 67 : for (auto ¶m : expr.get_params ())
805 : : {
806 : 37 : HIR::ClosureParam p = lower_closure_param (param);
807 : 37 : closure_params.push_back (std::move (p));
808 : 37 : }
809 : :
810 : 30 : auto crate_num = mappings->get_current_crate ();
811 : 60 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
812 : 30 : mappings->get_next_hir_id (crate_num),
813 : 30 : mappings->get_next_localdef_id (crate_num));
814 : :
815 : 30 : translated
816 : 30 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
817 : 90 : std::unique_ptr<HIR::Type> (closure_return_type),
818 : 60 : std::unique_ptr<HIR::Expr> (closure_expr),
819 : 60 : expr.get_has_move (), expr.get_outer_attrs (),
820 : 60 : expr.get_locus ());
821 : 30 : }
822 : :
823 : : void
824 : 0 : ASTLoweringExpr::visit (AST::FormatArgs &fmt)
825 : : {
826 : 0 : rust_sorry_at (fmt.get_locus (),
827 : : "FormatArgs lowering is not implemented yet");
828 : 0 : }
829 : :
830 : : } // namespace HIR
831 : : } // namespace Rust
|
