Branch data Line data Source code
1 : : // Copyright (C) 2020-2025 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 "optional.h"
21 : : #include "rust-ast-lower-base.h"
22 : : #include "rust-ast-lower-block.h"
23 : : #include "rust-ast-lower-struct-field-expr.h"
24 : : #include "rust-ast-lower-pattern.h"
25 : : #include "rust-ast-lower-type.h"
26 : : #include "rust-ast.h"
27 : : #include "rust-diagnostics.h"
28 : : #include "rust-system.h"
29 : : #include "tree/rust-hir-expr.h"
30 : :
31 : : namespace Rust {
32 : : namespace HIR {
33 : :
34 : 90655 : ASTLoweringExpr::ASTLoweringExpr ()
35 : 90655 : : ASTLoweringBase (), translated (nullptr), translated_array_elems (nullptr),
36 : 90655 : terminated (false)
37 : 90655 : {}
38 : :
39 : : HIR::Expr *
40 : 90655 : ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated)
41 : : {
42 : 90655 : ASTLoweringExpr resolver;
43 : 90655 : expr.accept_vis (resolver);
44 : 90655 : if (resolver.translated == nullptr)
45 : : {
46 : 0 : rust_fatal_error (expr.get_locus (), "Failed to lower expr: [%s]",
47 : 0 : expr.as_string ().c_str ());
48 : : return nullptr;
49 : : }
50 : :
51 : 90655 : resolver.mappings.insert_hir_expr (resolver.translated);
52 : 90655 : resolver.mappings.insert_location (
53 : 90655 : resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
54 : :
55 : 90655 : if (terminated != nullptr)
56 : 22115 : *terminated = resolver.terminated;
57 : :
58 : 90655 : return resolver.translated;
59 : 90655 : }
60 : :
61 : : void
62 : 879 : ASTLoweringExpr::visit (AST::TupleIndexExpr &expr)
63 : : {
64 : 879 : HIR::Expr *tuple_expr
65 : 879 : = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated);
66 : :
67 : 879 : auto crate_num = mappings.get_current_crate ();
68 : 1758 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
69 : 879 : mappings.get_next_hir_id (crate_num),
70 : 879 : UNKNOWN_LOCAL_DEFID);
71 : :
72 : 879 : translated
73 : 879 : = new HIR::TupleIndexExpr (mapping, std::unique_ptr<HIR::Expr> (tuple_expr),
74 : 879 : expr.get_tuple_index (), expr.get_outer_attrs (),
75 : 1758 : expr.get_locus ());
76 : 879 : }
77 : :
78 : : void
79 : 562 : ASTLoweringExpr::visit (AST::TupleExpr &expr)
80 : : {
81 : 562 : std::vector<std::unique_ptr<HIR::Expr>> tuple_elements;
82 : 1489 : for (auto &e : expr.get_tuple_elems ())
83 : : {
84 : 927 : HIR::Expr *t = ASTLoweringExpr::translate (*e);
85 : 927 : tuple_elements.push_back (std::unique_ptr<HIR::Expr> (t));
86 : : }
87 : :
88 : 562 : auto crate_num = mappings.get_current_crate ();
89 : 1124 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
90 : 562 : mappings.get_next_hir_id (crate_num),
91 : 562 : UNKNOWN_LOCAL_DEFID);
92 : :
93 : 562 : translated
94 : 562 : = new HIR::TupleExpr (std::move (mapping), std::move (tuple_elements),
95 : 1124 : expr.get_inner_attrs (), expr.get_outer_attrs (),
96 : 562 : expr.get_locus ());
97 : 562 : }
98 : :
99 : : void
100 : 387 : ASTLoweringExpr::visit (AST::IfExpr &expr)
101 : : {
102 : 387 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
103 : 387 : }
104 : :
105 : : void
106 : 541 : ASTLoweringExpr::visit (AST::IfExprConseqElse &expr)
107 : : {
108 : 541 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
109 : 541 : }
110 : :
111 : : void
112 : 19 : ASTLoweringExpr::visit (AST::IfLetExpr &expr)
113 : : {
114 : 19 : translated = ASTLoweringIfLetBlock::translate (expr);
115 : 19 : }
116 : :
117 : : void
118 : 14 : ASTLoweringExpr::visit (AST::IfLetExprConseqElse &expr)
119 : : {
120 : 14 : translated = ASTLoweringIfLetBlock::translate (expr);
121 : 14 : }
122 : :
123 : : void
124 : 1240 : ASTLoweringExpr::visit (AST::BlockExpr &expr)
125 : : {
126 : 1240 : translated = ASTLoweringBlock::translate (expr, &terminated);
127 : 1240 : }
128 : :
129 : : void
130 : 3430 : ASTLoweringExpr::visit (AST::UnsafeBlockExpr &expr)
131 : : {
132 : 3430 : translated = ASTLoweringBlock::translate (expr, &terminated);
133 : 3430 : }
134 : :
135 : : void
136 : 15934 : ASTLoweringExpr::visit (AST::PathInExpression &expr)
137 : : {
138 : 15934 : translated = ASTLowerPathInExpression::translate (expr);
139 : 15934 : }
140 : :
141 : : void
142 : 131 : ASTLoweringExpr::visit (AST::QualifiedPathInExpression &expr)
143 : : {
144 : 131 : translated = ASTLowerQualPathInExpression::translate (expr);
145 : 131 : }
146 : :
147 : : void
148 : 0 : ASTLoweringExpr::visit (AST::BoxExpr &expr)
149 : : {
150 : : // Not implemented
151 : 0 : rust_unreachable ();
152 : : }
153 : :
154 : : void
155 : 557 : ASTLoweringExpr::visit (AST::ReturnExpr &expr)
156 : : {
157 : 557 : terminated = true;
158 : 557 : HIR::Expr *return_expr
159 : 557 : = expr.has_returned_expr ()
160 : 557 : ? ASTLoweringExpr::translate (expr.get_returned_expr ())
161 : 557 : : nullptr;
162 : :
163 : 557 : auto crate_num = mappings.get_current_crate ();
164 : 1114 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
165 : 557 : mappings.get_next_hir_id (crate_num),
166 : 557 : UNKNOWN_LOCAL_DEFID);
167 : :
168 : 1114 : translated = new HIR::ReturnExpr (mapping, expr.get_locus (),
169 : 557 : std::unique_ptr<HIR::Expr> (return_expr));
170 : 557 : }
171 : :
172 : : void
173 : 10037 : ASTLoweringExpr::visit (AST::CallExpr &expr)
174 : : {
175 : 10037 : HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
176 : :
177 : 10037 : auto const &in_params = expr.get_params ();
178 : 10037 : std::vector<std::unique_ptr<HIR::Expr>> params;
179 : 21799 : for (auto ¶m : in_params)
180 : : {
181 : 11762 : auto trans = ASTLoweringExpr::translate (*param);
182 : 11762 : params.push_back (std::unique_ptr<HIR::Expr> (trans));
183 : : }
184 : :
185 : 10037 : auto crate_num = mappings.get_current_crate ();
186 : 10037 : Analysis::NodeMapping mapping (
187 : : crate_num, UNKNOWN_NODEID /* this can map back to the AST*/,
188 : 10037 : mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
189 : :
190 : 10037 : translated = new HIR::CallExpr (mapping, std::unique_ptr<HIR::Expr> (func),
191 : 10037 : std::move (params), expr.get_outer_attrs (),
192 : 20074 : expr.get_locus ());
193 : 10037 : }
194 : :
195 : : void
196 : 1560 : ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
197 : : {
198 : 1560 : HIR::PathExprSegment method_path
199 : 1560 : = lower_path_expr_seg (expr.get_method_name ());
200 : :
201 : 1560 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
202 : :
203 : 1560 : auto const &in_params = expr.get_params ();
204 : 1560 : std::vector<std::unique_ptr<HIR::Expr>> params;
205 : 2277 : for (auto ¶m : in_params)
206 : : {
207 : 717 : auto trans = ASTLoweringExpr::translate (*param);
208 : 717 : params.push_back (std::unique_ptr<HIR::Expr> (trans));
209 : : }
210 : :
211 : 1560 : auto crate_num = mappings.get_current_crate ();
212 : 3120 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
213 : 1560 : mappings.get_next_hir_id (crate_num),
214 : 1560 : UNKNOWN_LOCAL_DEFID);
215 : :
216 : 1560 : translated
217 : 1560 : = new HIR::MethodCallExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
218 : : method_path, std::move (params),
219 : 3120 : expr.get_outer_attrs (), expr.get_locus ());
220 : 1560 : }
221 : :
222 : : void
223 : 1942 : ASTLoweringExpr::visit (AST::AssignmentExpr &expr)
224 : : {
225 : 1942 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
226 : 1942 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
227 : :
228 : 1942 : auto crate_num = mappings.get_current_crate ();
229 : 3884 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
230 : 1942 : mappings.get_next_hir_id (crate_num),
231 : 1942 : UNKNOWN_LOCAL_DEFID);
232 : :
233 : 1942 : translated
234 : 1942 : = new HIR::AssignmentExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
235 : 3884 : std::unique_ptr<HIR::Expr> (rhs),
236 : 1942 : expr.get_locus ());
237 : 1942 : }
238 : :
239 : : void
240 : 19377 : ASTLoweringExpr::visit (AST::IdentifierExpr &expr)
241 : : {
242 : 19377 : auto crate_num = mappings.get_current_crate ();
243 : 38754 : Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (),
244 : 19377 : mappings.get_next_hir_id (crate_num),
245 : 19377 : UNKNOWN_LOCAL_DEFID);
246 : 19377 : Analysis::NodeMapping mapping2 (mapping1);
247 : :
248 : 19377 : HIR::PathIdentSegment ident_seg (expr.get_ident ().as_string ());
249 : 19377 : HIR::PathExprSegment seg (mapping1, ident_seg, expr.get_locus (),
250 : 19377 : HIR::GenericArgs::create_empty ());
251 : 38754 : translated = new HIR::PathInExpression (mapping2, {seg}, expr.get_locus (),
252 : 38754 : false, expr.get_outer_attrs ());
253 : 19377 : }
254 : :
255 : : void
256 : 402 : ASTLoweringExpr::visit (AST::ArrayExpr &expr)
257 : : {
258 : 402 : expr.get_array_elems ()->accept_vis (*this);
259 : 402 : rust_assert (translated_array_elems != nullptr);
260 : 402 : HIR::ArrayElems *elems = translated_array_elems;
261 : :
262 : 402 : auto crate_num = mappings.get_current_crate ();
263 : 804 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
264 : 402 : mappings.get_next_hir_id (crate_num),
265 : 402 : UNKNOWN_LOCAL_DEFID);
266 : :
267 : 402 : translated
268 : 402 : = new HIR::ArrayExpr (mapping, std::unique_ptr<HIR::ArrayElems> (elems),
269 : 804 : expr.get_inner_attrs (), expr.get_outer_attrs (),
270 : 804 : expr.get_locus ());
271 : 402 : }
272 : :
273 : : void
274 : 235 : ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr)
275 : : {
276 : 235 : HIR::Expr *array_expr = ASTLoweringExpr::translate (expr.get_array_expr ());
277 : 235 : HIR::Expr *array_index_expr
278 : 235 : = ASTLoweringExpr::translate (expr.get_index_expr ());
279 : :
280 : 235 : auto crate_num = mappings.get_current_crate ();
281 : 470 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
282 : 235 : mappings.get_next_hir_id (crate_num),
283 : 235 : UNKNOWN_LOCAL_DEFID);
284 : :
285 : 235 : translated
286 : 235 : = new HIR::ArrayIndexExpr (mapping, std::unique_ptr<HIR::Expr> (array_expr),
287 : 470 : std::unique_ptr<HIR::Expr> (array_index_expr),
288 : 470 : expr.get_outer_attrs (), expr.get_locus ());
289 : 235 : }
290 : :
291 : : void
292 : 273 : ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
293 : : {
294 : 273 : std::vector<std::unique_ptr<HIR::Expr>> elements;
295 : 1618 : for (auto &elem : elems.get_values ())
296 : : {
297 : 1345 : HIR::Expr *translated_elem = ASTLoweringExpr::translate (*elem);
298 : 1345 : elements.push_back (std::unique_ptr<HIR::Expr> (translated_elem));
299 : : }
300 : :
301 : 273 : auto crate_num = mappings.get_current_crate ();
302 : 273 : Analysis::NodeMapping mapping (mappings.get_current_crate (),
303 : : elems.get_node_id (),
304 : 273 : mappings.get_next_hir_id (crate_num),
305 : 273 : UNKNOWN_LOCAL_DEFID);
306 : :
307 : 273 : translated_array_elems
308 : 273 : = new HIR::ArrayElemsValues (mapping, std::move (elements));
309 : 273 : }
310 : :
311 : : void
312 : 129 : ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems)
313 : : {
314 : 129 : HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ());
315 : 129 : HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ());
316 : :
317 : 129 : auto crate_num = mappings.get_current_crate ();
318 : 129 : Analysis::NodeMapping mapping (mappings.get_current_crate (),
319 : : elems.get_node_id (),
320 : 129 : mappings.get_next_hir_id (crate_num),
321 : 129 : UNKNOWN_LOCAL_DEFID);
322 : :
323 : 129 : translated_array_elems
324 : 129 : = new HIR::ArrayElemsCopied (mapping, std::unique_ptr<HIR::Expr> (element),
325 : 258 : std::unique_ptr<HIR::Expr> (num_copies));
326 : 129 : }
327 : :
328 : : void
329 : 16213 : ASTLoweringExpr::visit (AST::LiteralExpr &expr)
330 : : {
331 : 16213 : auto crate_num = mappings.get_current_crate ();
332 : 32426 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
333 : 16213 : mappings.get_next_hir_id (crate_num),
334 : 16213 : UNKNOWN_LOCAL_DEFID);
335 : :
336 : 16213 : HIR::Literal l = lower_literal (expr.get_literal ());
337 : 16213 : translated = new HIR::LiteralExpr (mapping, std::move (l), expr.get_locus (),
338 : 32426 : expr.get_outer_attrs ());
339 : 16213 : }
340 : :
341 : : void
342 : 3146 : ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
343 : : {
344 : 3146 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
345 : 3146 : rust_assert (lhs != nullptr);
346 : 3146 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
347 : 3146 : rust_assert (rhs != nullptr);
348 : :
349 : 3146 : auto crate_num = mappings.get_current_crate ();
350 : 6292 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
351 : 3146 : mappings.get_next_hir_id (crate_num),
352 : 3146 : UNKNOWN_LOCAL_DEFID);
353 : :
354 : 6292 : translated = new HIR::ArithmeticOrLogicalExpr (
355 : 3146 : mapping, std::unique_ptr<HIR::Expr> (lhs), std::unique_ptr<HIR::Expr> (rhs),
356 : 3146 : expr.get_expr_type (), expr.get_locus ());
357 : 3146 : }
358 : :
359 : : void
360 : 1098 : ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
361 : : {
362 : 1098 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
363 : 1098 : rust_assert (lhs != nullptr);
364 : 1098 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
365 : 1098 : rust_assert (rhs != nullptr);
366 : :
367 : 1098 : auto crate_num = mappings.get_current_crate ();
368 : 2196 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
369 : 1098 : mappings.get_next_hir_id (crate_num),
370 : 1098 : UNKNOWN_LOCAL_DEFID);
371 : :
372 : 1098 : translated
373 : 1098 : = new HIR::ComparisonExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
374 : 2196 : std::unique_ptr<HIR::Expr> (rhs),
375 : 1098 : expr.get_expr_type (), expr.get_locus ());
376 : 1098 : }
377 : :
378 : : void
379 : 323 : ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr)
380 : : {
381 : 323 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
382 : 323 : rust_assert (lhs != nullptr);
383 : 323 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
384 : 323 : rust_assert (rhs != nullptr);
385 : :
386 : 323 : auto crate_num = mappings.get_current_crate ();
387 : 646 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
388 : 323 : mappings.get_next_hir_id (crate_num),
389 : 323 : UNKNOWN_LOCAL_DEFID);
390 : :
391 : 323 : translated
392 : 323 : = new HIR::LazyBooleanExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
393 : 646 : std::unique_ptr<HIR::Expr> (rhs),
394 : 323 : expr.get_expr_type (), expr.get_locus ());
395 : 323 : }
396 : :
397 : : void
398 : 375 : ASTLoweringExpr::visit (AST::NegationExpr &expr)
399 : : {
400 : 375 : HIR::Expr *negated_value
401 : 375 : = ASTLoweringExpr::translate (expr.get_negated_expr ());
402 : :
403 : 375 : auto crate_num = mappings.get_current_crate ();
404 : 750 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
405 : 375 : mappings.get_next_hir_id (crate_num),
406 : 375 : UNKNOWN_LOCAL_DEFID);
407 : 375 : translated
408 : 375 : = new HIR::NegationExpr (mapping,
409 : 375 : std::unique_ptr<HIR::Expr> (negated_value),
410 : 375 : expr.get_expr_type (), expr.get_outer_attrs (),
411 : 750 : expr.get_locus ());
412 : 375 : }
413 : :
414 : : void
415 : 4614 : ASTLoweringExpr::visit (AST::TypeCastExpr &expr)
416 : : {
417 : 4614 : HIR::Expr *expr_to_cast_to
418 : 4614 : = ASTLoweringExpr::translate (expr.get_casted_expr ());
419 : 4614 : HIR::Type *type_to_cast_to
420 : 4614 : = lower_type_no_bounds (expr.get_type_to_cast_to ());
421 : :
422 : 4614 : auto crate_num = mappings.get_current_crate ();
423 : 9228 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
424 : 4614 : mappings.get_next_hir_id (crate_num),
425 : 4614 : UNKNOWN_LOCAL_DEFID);
426 : :
427 : 4614 : translated
428 : 4614 : = new HIR::TypeCastExpr (mapping,
429 : 4614 : std::unique_ptr<HIR::Expr> (expr_to_cast_to),
430 : 9228 : std::unique_ptr<HIR::Type> (type_to_cast_to),
431 : 4614 : expr.get_locus ());
432 : 4614 : }
433 : :
434 : : void
435 : 241 : ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr)
436 : : {
437 : 241 : ArithmeticOrLogicalOperator op;
438 : 241 : switch (expr.get_expr_type ())
439 : : {
440 : : case CompoundAssignmentOperator::ADD:
441 : : op = ArithmeticOrLogicalOperator::ADD;
442 : : break;
443 : : case CompoundAssignmentOperator::SUBTRACT:
444 : : op = ArithmeticOrLogicalOperator::SUBTRACT;
445 : : break;
446 : : case CompoundAssignmentOperator::MULTIPLY:
447 : : op = ArithmeticOrLogicalOperator::MULTIPLY;
448 : : break;
449 : : case CompoundAssignmentOperator::DIVIDE:
450 : : op = ArithmeticOrLogicalOperator::DIVIDE;
451 : : break;
452 : : case CompoundAssignmentOperator::MODULUS:
453 : : op = ArithmeticOrLogicalOperator::MODULUS;
454 : : break;
455 : : case CompoundAssignmentOperator::BITWISE_AND:
456 : : op = ArithmeticOrLogicalOperator::BITWISE_AND;
457 : : break;
458 : : case CompoundAssignmentOperator::BITWISE_OR:
459 : : op = ArithmeticOrLogicalOperator::BITWISE_OR;
460 : : break;
461 : : case CompoundAssignmentOperator::BITWISE_XOR:
462 : : op = ArithmeticOrLogicalOperator::BITWISE_XOR;
463 : : break;
464 : : case CompoundAssignmentOperator::LEFT_SHIFT:
465 : : op = ArithmeticOrLogicalOperator::LEFT_SHIFT;
466 : : break;
467 : : case CompoundAssignmentOperator::RIGHT_SHIFT:
468 : : op = ArithmeticOrLogicalOperator::RIGHT_SHIFT;
469 : : break;
470 : 0 : default:
471 : 0 : rust_unreachable ();
472 : : }
473 : :
474 : 241 : HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
475 : 241 : HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
476 : :
477 : 241 : auto crate_num = mappings.get_current_crate ();
478 : 482 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
479 : 241 : mappings.get_next_hir_id (crate_num),
480 : 241 : UNKNOWN_LOCAL_DEFID);
481 : :
482 : 482 : translated = new HIR::CompoundAssignmentExpr (
483 : 241 : mapping, std::unique_ptr<HIR::Expr> (asignee_expr),
484 : 482 : std::unique_ptr<HIR::Expr> (value), op, expr.get_locus ());
485 : 241 : }
486 : :
487 : : void
488 : 63 : ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr)
489 : : {
490 : 63 : HIR::PathInExpression *path
491 : 63 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
492 : 63 : HIR::PathInExpression copied_path (*path);
493 : 63 : delete path;
494 : :
495 : 63 : auto crate_num = mappings.get_current_crate ();
496 : 126 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
497 : 63 : mappings.get_next_hir_id (crate_num),
498 : 63 : UNKNOWN_LOCAL_DEFID);
499 : :
500 : 126 : translated = new HIR::StructExprStruct (mapping, copied_path,
501 : 63 : struct_expr.get_inner_attrs (),
502 : 63 : struct_expr.get_outer_attrs (),
503 : 63 : struct_expr.get_locus ());
504 : 63 : }
505 : :
506 : : void
507 : 1094 : ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
508 : : {
509 : : // bit of a hack for now
510 : 1094 : HIR::PathInExpression *path
511 : 1094 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
512 : 1094 : HIR::PathInExpression copied_path (*path);
513 : 1094 : delete path;
514 : :
515 : 1094 : tl::optional<std::unique_ptr<HIR::StructBase>> base = tl::nullopt;
516 : 1094 : if (struct_expr.has_struct_base ())
517 : : {
518 : 72 : HIR::Expr *translated_base = ASTLoweringExpr::translate (
519 : 72 : struct_expr.get_struct_base ().get_base_struct ());
520 : 72 : base = tl::optional<std::unique_ptr<HIR::StructBase>> (
521 : 144 : std::make_unique<StructBase> (
522 : 144 : std::unique_ptr<HIR::Expr> (translated_base)));
523 : : }
524 : :
525 : 1094 : auto const &in_fields = struct_expr.get_fields ();
526 : 1094 : std::vector<std::unique_ptr<HIR::StructExprField>> fields;
527 : 3070 : for (auto &field : in_fields)
528 : : {
529 : 1976 : HIR::StructExprField *translated
530 : 1976 : = ASTLowerStructExprField::translate (*field);
531 : 1976 : fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
532 : : }
533 : :
534 : 1094 : auto crate_num = mappings.get_current_crate ();
535 : 2188 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
536 : 1094 : mappings.get_next_hir_id (crate_num),
537 : 1094 : UNKNOWN_LOCAL_DEFID);
538 : :
539 : 1094 : translated
540 : 1094 : = new HIR::StructExprStructFields (mapping, copied_path, std::move (fields),
541 : : struct_expr.get_locus (),
542 : : std::move (base),
543 : 1094 : struct_expr.get_inner_attrs (),
544 : 2260 : struct_expr.get_outer_attrs ());
545 : 1166 : }
546 : :
547 : : void
548 : 246 : ASTLoweringExpr::visit (AST::GroupedExpr &expr)
549 : : {
550 : 246 : HIR::Expr *paren_expr
551 : 246 : = ASTLoweringExpr::translate (expr.get_expr_in_parens ());
552 : :
553 : 246 : auto crate_num = mappings.get_current_crate ();
554 : 492 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
555 : 246 : mappings.get_next_hir_id (crate_num),
556 : 246 : UNKNOWN_LOCAL_DEFID);
557 : :
558 : 246 : translated
559 : 246 : = new HIR::GroupedExpr (mapping, std::unique_ptr<HIR::Expr> (paren_expr),
560 : 492 : expr.get_inner_attrs (), expr.get_outer_attrs (),
561 : 492 : expr.get_locus ());
562 : 246 : }
563 : :
564 : : void
565 : 1799 : ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
566 : : {
567 : 1799 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
568 : :
569 : 1799 : auto crate_num = mappings.get_current_crate ();
570 : 3598 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
571 : 1799 : mappings.get_next_hir_id (crate_num),
572 : 1799 : UNKNOWN_LOCAL_DEFID);
573 : 1799 : translated
574 : 1799 : = new HIR::FieldAccessExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
575 : 3598 : expr.get_field_name (), expr.get_outer_attrs (),
576 : 3598 : expr.get_locus ());
577 : 1799 : }
578 : :
579 : : void
580 : 124 : ASTLoweringExpr::visit (AST::LoopExpr &expr)
581 : : {
582 : 124 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
583 : 124 : }
584 : :
585 : : void
586 : 70 : ASTLoweringExpr::visit (AST::WhileLoopExpr &expr)
587 : : {
588 : 70 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
589 : 70 : }
590 : :
591 : : void
592 : 0 : ASTLoweringExpr::visit (AST::ForLoopExpr &expr)
593 : : {
594 : 0 : rust_unreachable ();
595 : : }
596 : :
597 : : void
598 : 94 : ASTLoweringExpr::visit (AST::BreakExpr &expr)
599 : : {
600 : 94 : tl::optional<HIR::Lifetime> break_label = tl::nullopt;
601 : 94 : if (expr.has_label ())
602 : 20 : break_label = lower_lifetime (expr.get_label_unchecked ().get_lifetime ());
603 : :
604 : 94 : HIR::Expr *break_expr
605 : 94 : = expr.has_break_expr ()
606 : 94 : ? ASTLoweringExpr::translate (expr.get_break_expr ())
607 : 94 : : nullptr;
608 : :
609 : 94 : auto crate_num = mappings.get_current_crate ();
610 : 188 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
611 : 94 : mappings.get_next_hir_id (crate_num),
612 : 94 : UNKNOWN_LOCAL_DEFID);
613 : :
614 : 94 : translated
615 : 94 : = new HIR::BreakExpr (mapping, expr.get_locus (), std ::move (break_label),
616 : 94 : std::unique_ptr<HIR::Expr> (break_expr),
617 : 188 : expr.get_outer_attrs ());
618 : 94 : }
619 : :
620 : : void
621 : 12 : ASTLoweringExpr::visit (AST::ContinueExpr &expr)
622 : : {
623 : 12 : tl::optional<HIR::Lifetime> break_label;
624 : 12 : if (expr.has_label ())
625 : 0 : break_label = lower_lifetime (expr.get_label_unchecked ());
626 : :
627 : 12 : auto crate_num = mappings.get_current_crate ();
628 : 24 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
629 : 12 : mappings.get_next_hir_id (crate_num),
630 : 12 : UNKNOWN_LOCAL_DEFID);
631 : :
632 : 12 : translated
633 : 12 : = new HIR::ContinueExpr (mapping, expr.get_locus (),
634 : 24 : std ::move (break_label), expr.get_outer_attrs ());
635 : 12 : }
636 : :
637 : : void
638 : 1371 : ASTLoweringExpr::visit (AST::BorrowExpr &expr)
639 : : {
640 : 1371 : HIR::Expr *borrow_lvalue
641 : 1371 : = ASTLoweringExpr::translate (expr.get_borrowed_expr ());
642 : :
643 : 1371 : auto crate_num = mappings.get_current_crate ();
644 : 2742 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
645 : 1371 : mappings.get_next_hir_id (crate_num),
646 : 1371 : UNKNOWN_LOCAL_DEFID);
647 : :
648 : 1371 : auto *borrow_expr
649 : 1371 : = new HIR::BorrowExpr (mapping, std::unique_ptr<HIR::Expr> (borrow_lvalue),
650 : 1371 : expr.get_mutability (), expr.is_raw_borrow (),
651 : 1371 : expr.get_outer_attrs (), expr.get_locus ());
652 : :
653 : 1371 : if (expr.get_is_double_borrow ())
654 : : {
655 : 27 : NodeId artificial_double_borrow_id = mappings.get_next_node_id ();
656 : 27 : Analysis::NodeMapping mapping (crate_num, artificial_double_borrow_id,
657 : 27 : mappings.get_next_hir_id (crate_num),
658 : 27 : UNKNOWN_LOCAL_DEFID);
659 : :
660 : 27 : borrow_expr
661 : 27 : = new HIR::BorrowExpr (mapping,
662 : 27 : std::unique_ptr<HIR::Expr> (borrow_expr),
663 : 27 : expr.get_mutability (), expr.is_raw_borrow (),
664 : 54 : expr.get_outer_attrs (), expr.get_locus ());
665 : : }
666 : :
667 : 1371 : translated = borrow_expr;
668 : 1371 : }
669 : :
670 : : void
671 : 1863 : ASTLoweringExpr::visit (AST::DereferenceExpr &expr)
672 : : {
673 : 1863 : HIR::Expr *dref_lvalue
674 : 1863 : = ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
675 : :
676 : 1863 : auto crate_num = mappings.get_current_crate ();
677 : 3726 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
678 : 1863 : mappings.get_next_hir_id (crate_num),
679 : 1863 : UNKNOWN_LOCAL_DEFID);
680 : :
681 : 1863 : translated
682 : 1863 : = new HIR::DereferenceExpr (mapping,
683 : 1863 : std::unique_ptr<HIR::Expr> (dref_lvalue),
684 : 3726 : expr.get_outer_attrs (), expr.get_locus ());
685 : 1863 : }
686 : :
687 : : void
688 : 472 : ASTLoweringExpr::visit (AST::MatchExpr &expr)
689 : : {
690 : 472 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
691 : 472 : }
692 : :
693 : : void
694 : 70 : ASTLoweringExpr::visit (AST::RangeFromToExpr &expr)
695 : : {
696 : 70 : auto crate_num = mappings.get_current_crate ();
697 : 140 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
698 : 70 : mappings.get_next_hir_id (crate_num),
699 : 70 : UNKNOWN_LOCAL_DEFID);
700 : :
701 : 70 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
702 : 70 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
703 : :
704 : 70 : translated
705 : 70 : = new HIR::RangeFromToExpr (mapping,
706 : 70 : std::unique_ptr<HIR::Expr> (range_from),
707 : 140 : std::unique_ptr<HIR::Expr> (range_to),
708 : 70 : expr.get_locus ());
709 : 70 : }
710 : :
711 : : void
712 : 8 : ASTLoweringExpr::visit (AST::RangeFromExpr &expr)
713 : : {
714 : 8 : auto crate_num = mappings.get_current_crate ();
715 : 16 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
716 : 8 : mappings.get_next_hir_id (crate_num),
717 : 8 : UNKNOWN_LOCAL_DEFID);
718 : :
719 : 8 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
720 : :
721 : 8 : translated
722 : 8 : = new HIR::RangeFromExpr (mapping, std::unique_ptr<HIR::Expr> (range_from),
723 : 8 : expr.get_locus ());
724 : 8 : }
725 : :
726 : : void
727 : 8 : ASTLoweringExpr::visit (AST::RangeToExpr &expr)
728 : : {
729 : 8 : auto crate_num = mappings.get_current_crate ();
730 : 16 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
731 : 8 : mappings.get_next_hir_id (crate_num),
732 : 8 : UNKNOWN_LOCAL_DEFID);
733 : :
734 : 8 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
735 : :
736 : 8 : translated
737 : 8 : = new HIR::RangeToExpr (mapping, std::unique_ptr<HIR::Expr> (range_to),
738 : 8 : expr.get_locus ());
739 : 8 : }
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 : 8 : ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr)
754 : : {
755 : 8 : auto crate_num = mappings.get_current_crate ();
756 : 16 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
757 : 8 : mappings.get_next_hir_id (crate_num),
758 : 8 : UNKNOWN_LOCAL_DEFID);
759 : :
760 : 8 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
761 : 8 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
762 : :
763 : 8 : translated
764 : 8 : = new HIR::RangeFromToInclExpr (mapping,
765 : 8 : std::unique_ptr<HIR::Expr> (range_from),
766 : 16 : std::unique_ptr<HIR::Expr> (range_to),
767 : 8 : expr.get_locus ());
768 : 8 : }
769 : :
770 : : void
771 : 28 : ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
772 : : {
773 : 28 : HIR::Expr *closure_expr
774 : 28 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
775 : :
776 : 28 : std::vector<HIR::ClosureParam> closure_params;
777 : 48 : for (auto ¶m : expr.get_params ())
778 : : {
779 : 20 : HIR::ClosureParam p = lower_closure_param (param);
780 : 20 : closure_params.push_back (std::move (p));
781 : 20 : }
782 : :
783 : 28 : auto crate_num = mappings.get_current_crate ();
784 : 56 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
785 : 28 : mappings.get_next_hir_id (crate_num),
786 : 28 : mappings.get_next_localdef_id (crate_num));
787 : :
788 : 28 : translated
789 : 28 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
790 : : nullptr /* closure_return_type */,
791 : 28 : std::unique_ptr<HIR::Expr> (closure_expr),
792 : 56 : expr.get_has_move (), expr.get_outer_attrs (),
793 : 28 : expr.get_locus ());
794 : 28 : }
795 : :
796 : : void
797 : 32 : ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
798 : : {
799 : 32 : HIR::Type *closure_return_type = nullptr;
800 : 32 : HIR::Expr *closure_expr
801 : 32 : = ASTLoweringExpr::translate (expr.get_definition_block ());
802 : :
803 : 32 : std::vector<HIR::ClosureParam> closure_params;
804 : 71 : for (auto ¶m : expr.get_params ())
805 : : {
806 : 39 : HIR::ClosureParam p = lower_closure_param (param);
807 : 39 : closure_params.push_back (std::move (p));
808 : 39 : }
809 : :
810 : 32 : auto crate_num = mappings.get_current_crate ();
811 : 64 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
812 : 32 : mappings.get_next_hir_id (crate_num),
813 : 32 : mappings.get_next_localdef_id (crate_num));
814 : :
815 : 32 : translated
816 : 32 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
817 : 96 : std::unique_ptr<HIR::Type> (closure_return_type),
818 : 64 : std::unique_ptr<HIR::Expr> (closure_expr),
819 : 64 : expr.get_has_move (), expr.get_outer_attrs (),
820 : 64 : expr.get_locus ());
821 : 32 : }
822 : :
823 : : HIR::InlineAsmOperand
824 : 13 : translate_operand_in (const AST::InlineAsmOperand &operand)
825 : : {
826 : 13 : auto in_value = operand.get_in ();
827 : :
828 : 13 : struct HIR::InlineAsmOperand::In in (
829 : : in_value.reg,
830 : 13 : std::unique_ptr<Expr> (ASTLoweringExpr::translate (*in_value.expr.get ())));
831 : 13 : return in;
832 : 13 : }
833 : :
834 : : HIR::InlineAsmOperand
835 : 20 : translate_operand_out (const AST::InlineAsmOperand &operand)
836 : : {
837 : 20 : auto out_value = operand.get_out ();
838 : 20 : struct HIR::InlineAsmOperand::Out out (out_value.reg, out_value.late,
839 : 20 : std::unique_ptr<Expr> (
840 : : ASTLoweringExpr::translate (
841 : 20 : *out_value.expr.get ())));
842 : 20 : return out;
843 : 20 : }
844 : : HIR::InlineAsmOperand
845 : 0 : translate_operand_inout (const AST::InlineAsmOperand &operand)
846 : : {
847 : 0 : auto inout_value = operand.get_in_out ();
848 : 0 : struct HIR::InlineAsmOperand::InOut inout (inout_value.reg, inout_value.late,
849 : 0 : std::unique_ptr<Expr> (
850 : : ASTLoweringExpr::translate (
851 : 0 : *inout_value.expr.get ())));
852 : 0 : return inout;
853 : 0 : }
854 : : HIR::InlineAsmOperand
855 : 0 : translate_operand_split_in_out (const AST::InlineAsmOperand &operand)
856 : : {
857 : 0 : auto split_in_out_value = operand.get_split_in_out ();
858 : 0 : struct HIR::InlineAsmOperand::SplitInOut split_in_out (
859 : 0 : split_in_out_value.reg, split_in_out_value.late,
860 : 0 : std::unique_ptr<Expr> (
861 : 0 : ASTLoweringExpr::translate (*split_in_out_value.in_expr.get ())),
862 : 0 : std::unique_ptr<Expr> (
863 : 0 : ASTLoweringExpr::translate (*split_in_out_value.out_expr.get ())));
864 : 0 : return split_in_out;
865 : 0 : }
866 : : HIR::InlineAsmOperand
867 : 0 : translate_operand_const (const AST::InlineAsmOperand &operand)
868 : : {
869 : 0 : auto const_value = operand.get_const ();
870 : 0 : struct HIR::AnonConst anon_const (const_value.anon_const.id,
871 : 0 : std::unique_ptr<Expr> (
872 : : ASTLoweringExpr::translate (
873 : 0 : *const_value.anon_const.expr.get ())));
874 : 0 : struct HIR::InlineAsmOperand::Const cnst
875 : : {
876 : : anon_const
877 : 0 : };
878 : 0 : return cnst;
879 : 0 : }
880 : :
881 : : HIR::InlineAsmOperand
882 : 0 : translate_operand_sym (const AST::InlineAsmOperand &operand)
883 : : {
884 : 0 : auto sym_value = operand.get_sym ();
885 : 0 : struct HIR::InlineAsmOperand::Sym sym (std::unique_ptr<Expr> (
886 : 0 : ASTLoweringExpr::translate (*sym_value.expr.get ())));
887 : 0 : return sym;
888 : 0 : }
889 : : HIR::InlineAsmOperand
890 : 0 : translate_operand_label (const AST::InlineAsmOperand &operand)
891 : : {
892 : 0 : auto label_value = operand.get_label ();
893 : 0 : struct HIR::InlineAsmOperand::Label label (label_value.label_name,
894 : 0 : std::unique_ptr<Expr> (
895 : : ASTLoweringExpr::translate (
896 : 0 : *label_value.expr.get ())));
897 : 0 : return label;
898 : 0 : }
899 : : HIR::InlineAsmOperand
900 : 33 : from_operand (const AST::InlineAsmOperand &operand)
901 : : {
902 : 33 : using RegisterType = AST::InlineAsmOperand::RegisterType;
903 : 33 : auto type = operand.get_register_type ();
904 : :
905 : : /*In,*/
906 : : /*Out,*/
907 : : /*InOut,*/
908 : : /*SplitInOut,*/
909 : : /*Const,*/
910 : : /*Sym,*/
911 : : /*Label,*/
912 : 33 : switch (type)
913 : : {
914 : 13 : case RegisterType::In:
915 : 13 : return translate_operand_in (operand);
916 : 20 : case RegisterType::Out:
917 : 20 : return translate_operand_out (operand);
918 : 0 : case RegisterType::InOut:
919 : 0 : return translate_operand_inout (operand);
920 : 0 : case RegisterType::SplitInOut:
921 : 0 : return translate_operand_split_in_out (operand);
922 : 0 : case RegisterType::Const:
923 : 0 : return translate_operand_const (operand);
924 : 0 : case RegisterType::Sym:
925 : 0 : return translate_operand_sym (operand);
926 : 0 : case RegisterType::Label:
927 : 0 : return translate_operand_label (operand);
928 : 0 : default:
929 : 0 : rust_unreachable ();
930 : : }
931 : : }
932 : : void
933 : 36 : ASTLoweringExpr::visit (AST::InlineAsm &expr)
934 : : {
935 : 36 : auto crate_num = mappings.get_current_crate ();
936 : 72 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
937 : 36 : mappings.get_next_hir_id (crate_num),
938 : 36 : mappings.get_next_localdef_id (crate_num));
939 : :
940 : 36 : std::vector<HIR::InlineAsmOperand> hir_operands;
941 : 36 : const std::vector<AST::InlineAsmOperand> &ast_operands = expr.get_operands ();
942 : : /*int ast_operands_size = ast_operands.size ();*/
943 : 69 : for (auto &operand : ast_operands)
944 : : {
945 : 33 : hir_operands.push_back (from_operand (operand));
946 : : }
947 : : /*int hir_operands_size = hir_operands.size ();*/
948 : :
949 : : /*rust_debug ("{bdbt} : There are %d ast operands prelowering and %d hir "*/
950 : : /* "operands after lowering\n",*/
951 : : /* ast_operands_size, hir_operands_size);*/
952 : 36 : translated
953 : 72 : = new HIR::InlineAsm (expr.get_locus (), expr.is_global_asm,
954 : 72 : expr.get_template_ (), expr.get_template_strs (),
955 : 36 : hir_operands, expr.get_clobber_abi (),
956 : 144 : expr.get_options (), mapping);
957 : 36 : }
958 : : void
959 : 0 : ASTLoweringExpr::visit (AST::FormatArgs &fmt)
960 : : {
961 : 0 : rust_sorry_at (fmt.get_locus (),
962 : : "FormatArgs lowering is not implemented yet");
963 : 0 : }
964 : :
965 : : } // namespace HIR
966 : : } // namespace Rust
|
