Line data Source code
1 : // Copyright (C) 2020-2026 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-builtin-ast-nodes.h"
28 : #include "rust-diagnostics.h"
29 : #include "rust-hir-map.h"
30 : #include "rust-system.h"
31 : #include "tree/rust-hir-expr.h"
32 :
33 : namespace Rust {
34 : namespace HIR {
35 :
36 124619 : ASTLoweringExpr::ASTLoweringExpr ()
37 124619 : : ASTLoweringBase (), translated (nullptr), translated_array_elems (nullptr),
38 124619 : terminated (false)
39 124619 : {}
40 :
41 : HIR::Expr *
42 124619 : ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated)
43 : {
44 124619 : ASTLoweringExpr resolver;
45 124619 : expr.accept_vis (resolver);
46 124619 : if (resolver.translated == nullptr)
47 : {
48 0 : rust_fatal_error (expr.get_locus (), "Failed to lower expr: [%s]",
49 0 : expr.as_string ().c_str ());
50 : return nullptr;
51 : }
52 :
53 124619 : resolver.mappings.insert_hir_expr (resolver.translated);
54 124619 : resolver.mappings.insert_location (
55 124619 : resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
56 :
57 124619 : if (terminated != nullptr)
58 29502 : *terminated = resolver.terminated;
59 :
60 124619 : return resolver.translated;
61 124619 : }
62 :
63 : void
64 900 : ASTLoweringExpr::visit (AST::TupleIndexExpr &expr)
65 : {
66 900 : HIR::Expr *tuple_expr
67 900 : = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated);
68 :
69 900 : auto crate_num = mappings.get_current_crate ();
70 1800 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
71 900 : mappings.get_next_hir_id (crate_num),
72 900 : UNKNOWN_LOCAL_DEFID);
73 :
74 900 : translated
75 900 : = new HIR::TupleIndexExpr (mapping, std::unique_ptr<HIR::Expr> (tuple_expr),
76 900 : expr.get_tuple_index (), expr.get_outer_attrs (),
77 1800 : expr.get_locus ());
78 900 : }
79 :
80 : void
81 558 : ASTLoweringExpr::visit (AST::TupleExpr &expr)
82 : {
83 558 : std::vector<std::unique_ptr<HIR::Expr>> tuple_elements;
84 558 : tuple_elements.reserve (expr.get_tuple_elems ().size ());
85 :
86 1530 : for (auto &e : expr.get_tuple_elems ())
87 972 : tuple_elements.emplace_back (ASTLoweringExpr::translate (*e));
88 :
89 558 : auto crate_num = mappings.get_current_crate ();
90 1116 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
91 558 : mappings.get_next_hir_id (crate_num),
92 558 : UNKNOWN_LOCAL_DEFID);
93 :
94 558 : translated
95 558 : = new HIR::TupleExpr (std::move (mapping), std::move (tuple_elements),
96 1116 : expr.get_inner_attrs (), expr.get_outer_attrs (),
97 558 : expr.get_locus ());
98 558 : }
99 :
100 : void
101 1220 : ASTLoweringExpr::visit (AST::IfExpr &expr)
102 : {
103 1220 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
104 1220 : }
105 :
106 : void
107 908 : ASTLoweringExpr::visit (AST::IfExprConseqElse &expr)
108 : {
109 908 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
110 908 : }
111 :
112 : void
113 17 : ASTLoweringExpr::visit (AST::IfLetExpr &expr)
114 : {
115 17 : translated = ASTLoweringIfLetBlock::translate (expr);
116 17 : }
117 :
118 : void
119 11 : ASTLoweringExpr::visit (AST::IfLetExprConseqElse &expr)
120 : {
121 11 : translated = ASTLoweringIfLetBlock::translate (expr);
122 11 : }
123 :
124 : void
125 1613 : ASTLoweringExpr::visit (AST::BlockExpr &expr)
126 : {
127 1613 : translated = ASTLoweringBlock::translate (expr, &terminated);
128 1613 : }
129 :
130 : void
131 689 : ASTLoweringExpr::visit (AST::AnonConst &expr)
132 : {
133 689 : auto &mappings = Analysis::Mappings::get ();
134 689 : auto crate_num = mappings.get_current_crate ();
135 1378 : auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (),
136 : mappings.get_next_hir_id (crate_num),
137 689 : UNKNOWN_LOCAL_DEFID);
138 :
139 689 : if (expr.is_deferred ())
140 : {
141 13 : translated = new HIR::AnonConst (std::move (mapping), expr.get_locus ());
142 : }
143 : else
144 : {
145 676 : auto inner_expr = ASTLoweringExpr::translate (expr.get_inner_expr ());
146 :
147 1352 : translated = new HIR::AnonConst (std::move (mapping),
148 676 : std::unique_ptr<Expr> (inner_expr),
149 676 : expr.get_locus ());
150 : }
151 689 : }
152 :
153 : void
154 15 : ASTLoweringExpr::visit (AST::ConstBlock &expr)
155 : {
156 15 : auto inner_expr = ASTLoweringExpr::translate (expr.get_const_expr ());
157 :
158 : // we know this will always be an `AnonConst`, or we have an issue. Let's
159 : // assert just to be sure.
160 15 : rust_assert (inner_expr->get_expression_type () == Expr::ExprType::AnonConst);
161 15 : auto anon_const = static_cast<AnonConst *> (inner_expr);
162 :
163 15 : auto &mappings = Analysis::Mappings::get ();
164 15 : auto crate_num = mappings.get_current_crate ();
165 30 : auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (),
166 : mappings.get_next_hir_id (crate_num),
167 15 : UNKNOWN_LOCAL_DEFID);
168 :
169 15 : translated
170 15 : = new HIR::ConstBlock (std::move (mapping), std::move (*anon_const),
171 15 : expr.get_locus (), expr.get_outer_attrs ());
172 15 : }
173 :
174 : void
175 3661 : ASTLoweringExpr::visit (AST::UnsafeBlockExpr &expr)
176 : {
177 3661 : translated = ASTLoweringBlock::translate (expr, &terminated);
178 3661 : }
179 :
180 : void
181 22093 : ASTLoweringExpr::visit (AST::PathInExpression &expr)
182 : {
183 22093 : translated = ASTLowerPathInExpression::translate (expr);
184 22093 : }
185 :
186 : void
187 116 : ASTLoweringExpr::visit (AST::QualifiedPathInExpression &expr)
188 : {
189 116 : translated = ASTLowerQualPathInExpression::translate (expr);
190 116 : }
191 :
192 : void
193 3 : ASTLoweringExpr::visit (AST::BoxExpr &expr)
194 : {
195 3 : HIR::Expr *box_expr = ASTLoweringExpr::translate (expr.get_boxed_expr ());
196 :
197 3 : auto crate_num = mappings.get_current_crate ();
198 6 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
199 3 : mappings.get_next_hir_id (crate_num),
200 3 : UNKNOWN_LOCAL_DEFID);
201 :
202 6 : translated = new HIR::BoxExpr (mapping, expr.get_locus (),
203 3 : std::unique_ptr<HIR::Expr> (box_expr));
204 3 : }
205 :
206 : void
207 537 : ASTLoweringExpr::visit (AST::ReturnExpr &expr)
208 : {
209 537 : terminated = true;
210 537 : HIR::Expr *return_expr
211 537 : = expr.has_returned_expr ()
212 537 : ? ASTLoweringExpr::translate (expr.get_returned_expr ())
213 : : nullptr;
214 :
215 537 : auto crate_num = mappings.get_current_crate ();
216 1074 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
217 537 : mappings.get_next_hir_id (crate_num),
218 537 : UNKNOWN_LOCAL_DEFID);
219 :
220 1074 : translated = new HIR::ReturnExpr (mapping, expr.get_locus (),
221 537 : std::unique_ptr<HIR::Expr> (return_expr));
222 537 : }
223 :
224 : void
225 12582 : ASTLoweringExpr::visit (AST::CallExpr &expr)
226 : {
227 12582 : HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
228 :
229 12582 : auto const &in_params = expr.get_params ();
230 :
231 12582 : std::vector<std::unique_ptr<HIR::Expr>> params;
232 12582 : params.reserve (in_params.size ());
233 :
234 26457 : for (auto ¶m : in_params)
235 13875 : params.emplace_back (ASTLoweringExpr::translate (*param));
236 :
237 12582 : auto crate_num = mappings.get_current_crate ();
238 12582 : Analysis::NodeMapping mapping (
239 : crate_num, UNKNOWN_NODEID /* this can map back to the AST*/,
240 12582 : mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
241 :
242 12582 : translated = new HIR::CallExpr (mapping, std::unique_ptr<HIR::Expr> (func),
243 12582 : std::move (params), expr.get_outer_attrs (),
244 25164 : expr.get_locus ());
245 12582 : }
246 :
247 : void
248 3050 : ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
249 : {
250 3050 : HIR::PathExprSegment method_path
251 3050 : = lower_path_expr_seg (expr.get_method_name ());
252 :
253 3050 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
254 :
255 3050 : auto const &in_params = expr.get_params ();
256 3050 : std::vector<std::unique_ptr<HIR::Expr>> params;
257 3050 : params.reserve (in_params.size ());
258 :
259 5107 : for (auto ¶m : in_params)
260 2057 : params.emplace_back (ASTLoweringExpr::translate (*param));
261 :
262 3050 : auto crate_num = mappings.get_current_crate ();
263 6100 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
264 3050 : mappings.get_next_hir_id (crate_num),
265 3050 : UNKNOWN_LOCAL_DEFID);
266 :
267 3050 : translated
268 3050 : = new HIR::MethodCallExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
269 : method_path, std::move (params),
270 6100 : expr.get_outer_attrs (), expr.get_locus ());
271 3050 : }
272 :
273 : void
274 2500 : ASTLoweringExpr::visit (AST::AssignmentExpr &expr)
275 : {
276 2500 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
277 2500 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
278 :
279 2500 : auto crate_num = mappings.get_current_crate ();
280 5000 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
281 2500 : mappings.get_next_hir_id (crate_num),
282 2500 : UNKNOWN_LOCAL_DEFID);
283 :
284 2500 : translated
285 2500 : = new HIR::AssignmentExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
286 5000 : std::unique_ptr<HIR::Expr> (rhs),
287 2500 : expr.get_locus ());
288 2500 : }
289 :
290 : void
291 24539 : ASTLoweringExpr::visit (AST::IdentifierExpr &expr)
292 : {
293 24539 : auto crate_num = mappings.get_current_crate ();
294 49078 : Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (),
295 24539 : mappings.get_next_hir_id (crate_num),
296 24539 : UNKNOWN_LOCAL_DEFID);
297 24539 : Analysis::NodeMapping mapping2 (mapping1);
298 :
299 49078 : HIR::PathIdentSegment ident_seg (expr.get_ident ().as_string ());
300 24539 : HIR::PathExprSegment seg (mapping1, ident_seg, expr.get_locus (),
301 49078 : HIR::GenericArgs::create_empty ());
302 49078 : translated = new HIR::PathInExpression (mapping2, {seg}, expr.get_locus (),
303 49078 : false, expr.get_outer_attrs ());
304 24539 : }
305 :
306 : void
307 434 : ASTLoweringExpr::visit (AST::ArrayExpr &expr)
308 : {
309 434 : expr.get_array_elems ()->accept_vis (*this);
310 434 : rust_assert (translated_array_elems != nullptr);
311 434 : HIR::ArrayElems *elems = translated_array_elems;
312 :
313 434 : auto crate_num = mappings.get_current_crate ();
314 868 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
315 434 : mappings.get_next_hir_id (crate_num),
316 434 : UNKNOWN_LOCAL_DEFID);
317 :
318 434 : translated
319 434 : = new HIR::ArrayExpr (mapping, std::unique_ptr<HIR::ArrayElems> (elems),
320 868 : expr.get_inner_attrs (), expr.get_outer_attrs (),
321 868 : expr.get_locus ());
322 434 : }
323 :
324 : void
325 291 : ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr)
326 : {
327 291 : HIR::Expr *array_expr = ASTLoweringExpr::translate (expr.get_array_expr ());
328 291 : HIR::Expr *array_index_expr
329 291 : = ASTLoweringExpr::translate (expr.get_index_expr ());
330 :
331 291 : auto crate_num = mappings.get_current_crate ();
332 582 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
333 291 : mappings.get_next_hir_id (crate_num),
334 291 : UNKNOWN_LOCAL_DEFID);
335 :
336 291 : translated
337 291 : = new HIR::ArrayIndexExpr (mapping, std::unique_ptr<HIR::Expr> (array_expr),
338 582 : std::unique_ptr<HIR::Expr> (array_index_expr),
339 582 : expr.get_outer_attrs (), expr.get_locus ());
340 291 : }
341 :
342 : void
343 312 : ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
344 : {
345 312 : std::vector<std::unique_ptr<HIR::Expr>> elements;
346 312 : elements.reserve (elems.get_values ().size ());
347 :
348 1833 : for (auto &elem : elems.get_values ())
349 1521 : elements.emplace_back (ASTLoweringExpr::translate (*elem));
350 :
351 312 : auto crate_num = mappings.get_current_crate ();
352 312 : Analysis::NodeMapping mapping (mappings.get_current_crate (),
353 : elems.get_node_id (),
354 312 : mappings.get_next_hir_id (crate_num),
355 312 : UNKNOWN_LOCAL_DEFID);
356 :
357 312 : translated_array_elems
358 312 : = new HIR::ArrayElemsValues (mapping, std::move (elements));
359 312 : }
360 :
361 : void
362 122 : ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems)
363 : {
364 122 : HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ());
365 122 : HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ());
366 :
367 122 : auto crate_num = mappings.get_current_crate ();
368 122 : Analysis::NodeMapping mapping (mappings.get_current_crate (),
369 : elems.get_node_id (),
370 122 : mappings.get_next_hir_id (crate_num),
371 122 : UNKNOWN_LOCAL_DEFID);
372 :
373 122 : translated_array_elems
374 122 : = new HIR::ArrayElemsCopied (mapping, std::unique_ptr<HIR::Expr> (element),
375 244 : std::unique_ptr<HIR::Expr> (num_copies));
376 122 : }
377 :
378 : void
379 20637 : ASTLoweringExpr::visit (AST::LiteralExpr &expr)
380 : {
381 20637 : auto crate_num = mappings.get_current_crate ();
382 41274 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
383 20637 : mappings.get_next_hir_id (crate_num),
384 20637 : UNKNOWN_LOCAL_DEFID);
385 :
386 20637 : HIR::Literal l = lower_literal (expr.get_literal ());
387 20637 : translated = new HIR::LiteralExpr (mapping, std::move (l), expr.get_locus (),
388 41274 : expr.get_outer_attrs ());
389 20637 : }
390 :
391 : void
392 3388 : ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
393 : {
394 3388 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
395 3388 : rust_assert (lhs != nullptr);
396 3388 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
397 3388 : rust_assert (rhs != nullptr);
398 :
399 3388 : auto crate_num = mappings.get_current_crate ();
400 6776 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
401 3388 : mappings.get_next_hir_id (crate_num),
402 3388 : UNKNOWN_LOCAL_DEFID);
403 :
404 6776 : translated = new HIR::ArithmeticOrLogicalExpr (
405 3388 : mapping, std::unique_ptr<HIR::Expr> (lhs), std::unique_ptr<HIR::Expr> (rhs),
406 3388 : expr.get_expr_type (), expr.get_locus ());
407 3388 : }
408 :
409 : void
410 3536 : ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
411 : {
412 3536 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
413 3536 : rust_assert (lhs != nullptr);
414 3536 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
415 3536 : rust_assert (rhs != nullptr);
416 :
417 3536 : auto crate_num = mappings.get_current_crate ();
418 7072 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
419 3536 : mappings.get_next_hir_id (crate_num),
420 3536 : UNKNOWN_LOCAL_DEFID);
421 :
422 3536 : translated
423 3536 : = new HIR::ComparisonExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
424 7072 : std::unique_ptr<HIR::Expr> (rhs),
425 3536 : expr.get_expr_type (), expr.get_locus ());
426 3536 : }
427 :
428 : void
429 403 : ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr)
430 : {
431 403 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
432 403 : rust_assert (lhs != nullptr);
433 403 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
434 403 : rust_assert (rhs != nullptr);
435 :
436 403 : auto crate_num = mappings.get_current_crate ();
437 806 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
438 403 : mappings.get_next_hir_id (crate_num),
439 403 : UNKNOWN_LOCAL_DEFID);
440 :
441 403 : translated
442 403 : = new HIR::LazyBooleanExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
443 806 : std::unique_ptr<HIR::Expr> (rhs),
444 403 : expr.get_expr_type (), expr.get_locus ());
445 403 : }
446 :
447 : void
448 687 : ASTLoweringExpr::visit (AST::NegationExpr &expr)
449 : {
450 687 : HIR::Expr *negated_value
451 687 : = ASTLoweringExpr::translate (expr.get_negated_expr ());
452 :
453 687 : auto crate_num = mappings.get_current_crate ();
454 1374 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
455 687 : mappings.get_next_hir_id (crate_num),
456 687 : UNKNOWN_LOCAL_DEFID);
457 687 : translated
458 687 : = new HIR::NegationExpr (mapping,
459 687 : std::unique_ptr<HIR::Expr> (negated_value),
460 687 : expr.get_expr_type (), expr.get_outer_attrs (),
461 1374 : expr.get_locus ());
462 687 : }
463 :
464 : void
465 5222 : ASTLoweringExpr::visit (AST::TypeCastExpr &expr)
466 : {
467 5222 : HIR::Expr *expr_to_cast_to
468 5222 : = ASTLoweringExpr::translate (expr.get_casted_expr ());
469 5222 : HIR::Type *type_to_cast_to
470 5222 : = lower_type_no_bounds (expr.get_type_to_cast_to ());
471 :
472 5222 : auto crate_num = mappings.get_current_crate ();
473 10444 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
474 5222 : mappings.get_next_hir_id (crate_num),
475 5222 : UNKNOWN_LOCAL_DEFID);
476 :
477 5222 : translated
478 5222 : = new HIR::TypeCastExpr (mapping,
479 5222 : std::unique_ptr<HIR::Expr> (expr_to_cast_to),
480 10444 : std::unique_ptr<HIR::Type> (type_to_cast_to),
481 5222 : expr.get_locus ());
482 5222 : }
483 :
484 : void
485 677 : ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr)
486 : {
487 677 : ArithmeticOrLogicalOperator op;
488 677 : switch (expr.get_expr_type ())
489 : {
490 : case CompoundAssignmentOperator::ADD:
491 : op = ArithmeticOrLogicalOperator::ADD;
492 : break;
493 : case CompoundAssignmentOperator::SUBTRACT:
494 : op = ArithmeticOrLogicalOperator::SUBTRACT;
495 : break;
496 : case CompoundAssignmentOperator::MULTIPLY:
497 : op = ArithmeticOrLogicalOperator::MULTIPLY;
498 : break;
499 : case CompoundAssignmentOperator::DIVIDE:
500 : op = ArithmeticOrLogicalOperator::DIVIDE;
501 : break;
502 : case CompoundAssignmentOperator::MODULUS:
503 : op = ArithmeticOrLogicalOperator::MODULUS;
504 : break;
505 : case CompoundAssignmentOperator::BITWISE_AND:
506 : op = ArithmeticOrLogicalOperator::BITWISE_AND;
507 : break;
508 : case CompoundAssignmentOperator::BITWISE_OR:
509 : op = ArithmeticOrLogicalOperator::BITWISE_OR;
510 : break;
511 : case CompoundAssignmentOperator::BITWISE_XOR:
512 : op = ArithmeticOrLogicalOperator::BITWISE_XOR;
513 : break;
514 : case CompoundAssignmentOperator::LEFT_SHIFT:
515 : op = ArithmeticOrLogicalOperator::LEFT_SHIFT;
516 : break;
517 : case CompoundAssignmentOperator::RIGHT_SHIFT:
518 : op = ArithmeticOrLogicalOperator::RIGHT_SHIFT;
519 : break;
520 0 : default:
521 0 : rust_unreachable ();
522 : }
523 :
524 677 : HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
525 677 : HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
526 :
527 677 : auto crate_num = mappings.get_current_crate ();
528 1354 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
529 677 : mappings.get_next_hir_id (crate_num),
530 677 : UNKNOWN_LOCAL_DEFID);
531 :
532 1354 : translated = new HIR::CompoundAssignmentExpr (
533 677 : mapping, std::unique_ptr<HIR::Expr> (asignee_expr),
534 1354 : std::unique_ptr<HIR::Expr> (value), op, expr.get_locus ());
535 677 : }
536 :
537 : void
538 81 : ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr)
539 : {
540 81 : HIR::PathInExpression *path
541 81 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
542 81 : HIR::PathInExpression copied_path (*path);
543 81 : delete path;
544 :
545 81 : auto crate_num = mappings.get_current_crate ();
546 162 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
547 81 : mappings.get_next_hir_id (crate_num),
548 81 : UNKNOWN_LOCAL_DEFID);
549 :
550 162 : translated = new HIR::StructExprStruct (mapping, copied_path,
551 81 : struct_expr.get_inner_attrs (),
552 81 : struct_expr.get_outer_attrs (),
553 81 : struct_expr.get_locus ());
554 81 : }
555 :
556 : void
557 1371 : ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
558 : {
559 : // bit of a hack for now
560 1371 : HIR::PathInExpression *path
561 1371 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
562 1371 : HIR::PathInExpression copied_path (*path);
563 1371 : delete path;
564 :
565 1371 : tl::optional<std::unique_ptr<HIR::StructBase>> base = tl::nullopt;
566 1371 : if (struct_expr.has_struct_base ())
567 : {
568 63 : HIR::Expr *translated_base = ASTLoweringExpr::translate (
569 63 : struct_expr.get_struct_base ().get_base_struct ());
570 63 : base = tl::optional<std::unique_ptr<HIR::StructBase>> (
571 126 : std::make_unique<StructBase> (
572 126 : std::unique_ptr<HIR::Expr> (translated_base)));
573 : }
574 :
575 1371 : auto const &in_fields = struct_expr.get_fields ();
576 :
577 1371 : std::vector<std::unique_ptr<HIR::StructExprField>> fields;
578 1371 : fields.reserve (in_fields.size ());
579 :
580 3707 : for (auto &field : in_fields)
581 2336 : fields.emplace_back (ASTLowerStructExprField::translate (*field));
582 :
583 1371 : auto crate_num = mappings.get_current_crate ();
584 2742 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
585 1371 : mappings.get_next_hir_id (crate_num),
586 1371 : UNKNOWN_LOCAL_DEFID);
587 :
588 1371 : translated
589 1371 : = new HIR::StructExprStructFields (mapping, copied_path, std::move (fields),
590 : struct_expr.get_locus (),
591 : std::move (base),
592 1371 : struct_expr.get_inner_attrs (),
593 2805 : struct_expr.get_outer_attrs ());
594 1434 : }
595 :
596 : void
597 315 : ASTLoweringExpr::visit (AST::GroupedExpr &expr)
598 : {
599 315 : HIR::Expr *paren_expr
600 315 : = ASTLoweringExpr::translate (expr.get_expr_in_parens ());
601 :
602 315 : auto crate_num = mappings.get_current_crate ();
603 630 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
604 315 : mappings.get_next_hir_id (crate_num),
605 315 : UNKNOWN_LOCAL_DEFID);
606 :
607 315 : translated
608 315 : = new HIR::GroupedExpr (mapping, std::unique_ptr<HIR::Expr> (paren_expr),
609 630 : expr.get_inner_attrs (), expr.get_outer_attrs (),
610 630 : expr.get_locus ());
611 315 : }
612 :
613 : void
614 5055 : ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
615 : {
616 5055 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
617 :
618 5055 : auto crate_num = mappings.get_current_crate ();
619 10110 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
620 5055 : mappings.get_next_hir_id (crate_num),
621 5055 : UNKNOWN_LOCAL_DEFID);
622 5055 : translated
623 5055 : = new HIR::FieldAccessExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
624 10110 : expr.get_field_name (), expr.get_outer_attrs (),
625 10110 : expr.get_locus ());
626 5055 : }
627 :
628 : void
629 127 : ASTLoweringExpr::visit (AST::LoopExpr &expr)
630 : {
631 127 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
632 127 : }
633 :
634 : void
635 78 : ASTLoweringExpr::visit (AST::WhileLoopExpr &expr)
636 : {
637 78 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
638 78 : }
639 :
640 : void
641 91 : ASTLoweringExpr::visit (AST::BreakExpr &expr)
642 : {
643 91 : tl::optional<HIR::Lifetime> break_label = tl::nullopt;
644 91 : if (expr.has_label ())
645 22 : break_label = lower_lifetime (expr.get_label_unchecked ().get_lifetime ());
646 :
647 91 : HIR::Expr *break_expr
648 91 : = expr.has_break_expr ()
649 91 : ? ASTLoweringExpr::translate (expr.get_break_expr_unchecked ())
650 : : nullptr;
651 :
652 91 : auto crate_num = mappings.get_current_crate ();
653 182 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
654 91 : mappings.get_next_hir_id (crate_num),
655 91 : UNKNOWN_LOCAL_DEFID);
656 :
657 91 : translated
658 91 : = new HIR::BreakExpr (mapping, expr.get_locus (), std ::move (break_label),
659 91 : std::unique_ptr<HIR::Expr> (break_expr),
660 182 : expr.get_outer_attrs ());
661 91 : }
662 :
663 : void
664 16 : ASTLoweringExpr::visit (AST::ContinueExpr &expr)
665 : {
666 16 : tl::optional<HIR::Lifetime> break_label;
667 16 : if (expr.has_label ())
668 2 : break_label = lower_lifetime (expr.get_label_unchecked ());
669 :
670 16 : auto crate_num = mappings.get_current_crate ();
671 32 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
672 16 : mappings.get_next_hir_id (crate_num),
673 16 : UNKNOWN_LOCAL_DEFID);
674 :
675 16 : translated
676 16 : = new HIR::ContinueExpr (mapping, expr.get_locus (),
677 32 : std ::move (break_label), expr.get_outer_attrs ());
678 16 : }
679 :
680 : void
681 2006 : ASTLoweringExpr::visit (AST::BorrowExpr &expr)
682 : {
683 2006 : HIR::Expr *borrow_lvalue
684 2006 : = ASTLoweringExpr::translate (expr.get_borrowed_expr ());
685 :
686 2006 : auto crate_num = mappings.get_current_crate ();
687 4012 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
688 2006 : mappings.get_next_hir_id (crate_num),
689 2006 : UNKNOWN_LOCAL_DEFID);
690 :
691 2006 : auto *borrow_expr
692 2006 : = new HIR::BorrowExpr (mapping, std::unique_ptr<HIR::Expr> (borrow_lvalue),
693 2006 : expr.get_mutability (), expr.is_raw_borrow (),
694 2006 : expr.get_outer_attrs (), expr.get_locus ());
695 :
696 2006 : if (expr.get_is_double_borrow ())
697 : {
698 23 : NodeId artificial_double_borrow_id = mappings.get_next_node_id ();
699 23 : Analysis::NodeMapping mapping (crate_num, artificial_double_borrow_id,
700 23 : mappings.get_next_hir_id (crate_num),
701 23 : UNKNOWN_LOCAL_DEFID);
702 :
703 23 : borrow_expr
704 23 : = new HIR::BorrowExpr (mapping,
705 23 : std::unique_ptr<HIR::Expr> (borrow_expr),
706 23 : expr.get_mutability (), expr.is_raw_borrow (),
707 46 : expr.get_outer_attrs (), expr.get_locus ());
708 : }
709 :
710 2006 : translated = borrow_expr;
711 2006 : }
712 :
713 : void
714 3918 : ASTLoweringExpr::visit (AST::DereferenceExpr &expr)
715 : {
716 3918 : HIR::Expr *dref_lvalue
717 3918 : = ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
718 :
719 3918 : auto crate_num = mappings.get_current_crate ();
720 7836 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
721 3918 : mappings.get_next_hir_id (crate_num),
722 3918 : UNKNOWN_LOCAL_DEFID);
723 :
724 3918 : translated
725 3918 : = new HIR::DereferenceExpr (mapping,
726 3918 : std::unique_ptr<HIR::Expr> (dref_lvalue),
727 7836 : expr.get_outer_attrs (), expr.get_locus ());
728 3918 : }
729 :
730 : void
731 1077 : ASTLoweringExpr::visit (AST::MatchExpr &expr)
732 : {
733 1077 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
734 1077 : }
735 :
736 : void
737 66 : ASTLoweringExpr::visit (AST::RangeFromToExpr &expr)
738 : {
739 66 : auto crate_num = mappings.get_current_crate ();
740 132 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
741 66 : mappings.get_next_hir_id (crate_num),
742 66 : UNKNOWN_LOCAL_DEFID);
743 :
744 66 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
745 66 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
746 :
747 66 : translated
748 66 : = new HIR::RangeFromToExpr (mapping,
749 66 : std::unique_ptr<HIR::Expr> (range_from),
750 132 : std::unique_ptr<HIR::Expr> (range_to),
751 66 : expr.get_locus ());
752 66 : }
753 :
754 : void
755 7 : ASTLoweringExpr::visit (AST::RangeFromExpr &expr)
756 : {
757 7 : auto crate_num = mappings.get_current_crate ();
758 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
759 7 : mappings.get_next_hir_id (crate_num),
760 7 : UNKNOWN_LOCAL_DEFID);
761 :
762 7 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
763 :
764 7 : translated
765 7 : = new HIR::RangeFromExpr (mapping, std::unique_ptr<HIR::Expr> (range_from),
766 7 : expr.get_locus ());
767 7 : }
768 :
769 : void
770 7 : ASTLoweringExpr::visit (AST::RangeToExpr &expr)
771 : {
772 7 : auto crate_num = mappings.get_current_crate ();
773 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
774 7 : mappings.get_next_hir_id (crate_num),
775 7 : UNKNOWN_LOCAL_DEFID);
776 :
777 7 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
778 :
779 7 : translated
780 7 : = new HIR::RangeToExpr (mapping, std::unique_ptr<HIR::Expr> (range_to),
781 7 : expr.get_locus ());
782 7 : }
783 :
784 : void
785 0 : ASTLoweringExpr::visit (AST::RangeFullExpr &expr)
786 : {
787 0 : auto crate_num = mappings.get_current_crate ();
788 0 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
789 0 : mappings.get_next_hir_id (crate_num),
790 0 : UNKNOWN_LOCAL_DEFID);
791 :
792 0 : translated = new HIR::RangeFullExpr (mapping, expr.get_locus ());
793 0 : }
794 :
795 : void
796 7 : ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr)
797 : {
798 7 : auto crate_num = mappings.get_current_crate ();
799 14 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
800 7 : mappings.get_next_hir_id (crate_num),
801 7 : UNKNOWN_LOCAL_DEFID);
802 :
803 7 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
804 7 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
805 :
806 7 : translated
807 7 : = new HIR::RangeFromToInclExpr (mapping,
808 7 : std::unique_ptr<HIR::Expr> (range_from),
809 14 : std::unique_ptr<HIR::Expr> (range_to),
810 7 : expr.get_locus ());
811 7 : }
812 :
813 : void
814 36 : ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
815 : {
816 36 : HIR::Expr *closure_expr
817 36 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
818 :
819 36 : std::vector<HIR::ClosureParam> closure_params;
820 36 : closure_params.reserve (expr.get_params ().size ());
821 :
822 60 : for (auto ¶m : expr.get_params ())
823 24 : closure_params.emplace_back (lower_closure_param (param));
824 :
825 36 : auto crate_num = mappings.get_current_crate ();
826 72 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
827 36 : mappings.get_next_hir_id (crate_num),
828 36 : mappings.get_next_localdef_id (crate_num));
829 :
830 36 : translated
831 36 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
832 : nullptr /* closure_return_type */,
833 36 : std::unique_ptr<HIR::Expr> (closure_expr),
834 72 : expr.get_has_move (), expr.get_outer_attrs (),
835 36 : expr.get_locus ());
836 36 : }
837 :
838 : void
839 30 : ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
840 : {
841 30 : HIR::Type *closure_return_type = nullptr;
842 30 : HIR::Expr *closure_expr
843 30 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
844 :
845 30 : std::vector<HIR::ClosureParam> closure_params;
846 30 : closure_params.reserve (expr.get_params ().size ());
847 :
848 67 : for (auto ¶m : expr.get_params ())
849 37 : closure_params.emplace_back (lower_closure_param (param));
850 :
851 30 : auto crate_num = mappings.get_current_crate ();
852 60 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
853 30 : mappings.get_next_hir_id (crate_num),
854 30 : mappings.get_next_localdef_id (crate_num));
855 :
856 30 : translated
857 30 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
858 90 : std::unique_ptr<HIR::Type> (closure_return_type),
859 60 : std::unique_ptr<HIR::Expr> (closure_expr),
860 60 : expr.get_has_move (), expr.get_outer_attrs (),
861 60 : expr.get_locus ());
862 30 : }
863 :
864 : HIR::InlineAsmOperand
865 10 : translate_operand_in (const AST::InlineAsmOperand &operand)
866 : {
867 10 : auto in_value = operand.get_in ();
868 :
869 10 : struct HIR::InlineAsmOperand::In in (
870 : in_value.reg,
871 10 : std::unique_ptr<Expr> (ASTLoweringExpr::translate (*in_value.expr.get ())));
872 10 : return in;
873 10 : }
874 :
875 : HIR::InlineAsmOperand
876 17 : translate_operand_out (const AST::InlineAsmOperand &operand)
877 : {
878 17 : auto out_value = operand.get_out ();
879 17 : struct HIR::InlineAsmOperand::Out out (out_value.reg, out_value.late,
880 17 : std::unique_ptr<Expr> (
881 : ASTLoweringExpr::translate (
882 17 : *out_value.expr.get ())));
883 17 : return out;
884 17 : }
885 :
886 : HIR::InlineAsmOperand
887 0 : translate_operand_inout (const AST::InlineAsmOperand &operand)
888 : {
889 0 : auto inout_value = operand.get_in_out ();
890 0 : struct HIR::InlineAsmOperand::InOut inout (inout_value.reg, inout_value.late,
891 0 : std::unique_ptr<Expr> (
892 : ASTLoweringExpr::translate (
893 0 : *inout_value.expr.get ())));
894 0 : return inout;
895 0 : }
896 :
897 : HIR::InlineAsmOperand
898 2 : translate_operand_split_in_out (const AST::InlineAsmOperand &operand)
899 : {
900 2 : auto split_in_out_value = operand.get_split_in_out ();
901 2 : struct HIR::InlineAsmOperand::SplitInOut split_in_out (
902 2 : split_in_out_value.reg, split_in_out_value.late,
903 2 : std::unique_ptr<Expr> (
904 2 : ASTLoweringExpr::translate (*split_in_out_value.in_expr.get ())),
905 2 : std::unique_ptr<Expr> (
906 2 : ASTLoweringExpr::translate (*split_in_out_value.out_expr.get ())));
907 2 : return split_in_out;
908 2 : }
909 :
910 : HIR::InlineAsmOperand
911 0 : translate_operand_const (const AST::InlineAsmOperand &operand)
912 : {
913 0 : auto const_value = operand.get_const ();
914 :
915 0 : auto inner_expr = ASTLoweringExpr::translate (const_value.anon_const);
916 :
917 : // Like `ConstBlock`, we know this should only be an `AnonConst` - let's
918 : // assert to make sure and static cast
919 0 : rust_assert (inner_expr->get_expression_type () == Expr::ExprType::AnonConst);
920 :
921 0 : auto anon_const = static_cast<AnonConst *> (inner_expr);
922 :
923 0 : return HIR::InlineAsmOperand::Const{*anon_const};
924 0 : }
925 :
926 : HIR::InlineAsmOperand
927 0 : translate_operand_sym (const AST::InlineAsmOperand &operand)
928 : {
929 0 : auto sym_value = operand.get_sym ();
930 0 : struct HIR::InlineAsmOperand::Sym sym (std::unique_ptr<Expr> (
931 0 : ASTLoweringExpr::translate (*sym_value.expr.get ())));
932 0 : return sym;
933 0 : }
934 : HIR::InlineAsmOperand
935 0 : translate_operand_label (const AST::InlineAsmOperand &operand)
936 : {
937 0 : auto label_value = operand.get_label ();
938 0 : struct HIR::InlineAsmOperand::Label label (label_value.label_name,
939 0 : std::unique_ptr<Expr> (
940 : ASTLoweringExpr::translate (
941 0 : *label_value.expr.get ())));
942 0 : return label;
943 0 : }
944 : HIR::InlineAsmOperand
945 29 : from_operand (const AST::InlineAsmOperand &operand)
946 : {
947 29 : using RegisterType = AST::InlineAsmOperand::RegisterType;
948 29 : auto type = operand.get_register_type ();
949 :
950 : /*In,*/
951 : /*Out,*/
952 : /*InOut,*/
953 : /*SplitInOut,*/
954 : /*Const,*/
955 : /*Sym,*/
956 : /*Label,*/
957 29 : switch (type)
958 : {
959 10 : case RegisterType::In:
960 10 : return translate_operand_in (operand);
961 17 : case RegisterType::Out:
962 17 : return translate_operand_out (operand);
963 0 : case RegisterType::InOut:
964 0 : return translate_operand_inout (operand);
965 2 : case RegisterType::SplitInOut:
966 2 : return translate_operand_split_in_out (operand);
967 0 : case RegisterType::Const:
968 0 : return translate_operand_const (operand);
969 0 : case RegisterType::Sym:
970 0 : return translate_operand_sym (operand);
971 0 : case RegisterType::Label:
972 0 : return translate_operand_label (operand);
973 0 : default:
974 0 : rust_unreachable ();
975 : }
976 : }
977 : void
978 27 : ASTLoweringExpr::visit (AST::InlineAsm &expr)
979 : {
980 27 : auto crate_num = mappings.get_current_crate ();
981 54 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
982 27 : mappings.get_next_hir_id (crate_num),
983 27 : mappings.get_next_localdef_id (crate_num));
984 :
985 27 : std::vector<HIR::InlineAsmOperand> hir_operands;
986 27 : const std::vector<AST::InlineAsmOperand> &ast_operands = expr.get_operands ();
987 : /*int ast_operands_size = ast_operands.size ();*/
988 56 : for (auto &operand : ast_operands)
989 : {
990 29 : hir_operands.push_back (from_operand (operand));
991 : }
992 : /*int hir_operands_size = hir_operands.size ();*/
993 :
994 : /*rust_debug ("{bdbt} : There are %d ast operands prelowering and %d hir "*/
995 : /* "operands after lowering\n",*/
996 : /* ast_operands_size, hir_operands_size);*/
997 27 : translated
998 54 : = new HIR::InlineAsm (expr.get_locus (), expr.is_global_asm,
999 54 : expr.get_template_ (), expr.get_template_strs (),
1000 27 : hir_operands, expr.get_clobber_abi (),
1001 108 : expr.get_options (), mapping);
1002 27 : }
1003 :
1004 : namespace {
1005 : // We're not really supporting llvm_asm, only the bare minimum for libcore's
1006 : // blackbox
1007 : // llvm_asm!("" : : "r"(&mut dummy) : "memory" : "volatile");
1008 : bool
1009 2 : check_llvm_asm_support (const std::vector<LlvmOperand> &inputs,
1010 : const std::vector<LlvmOperand> &outputs,
1011 : const AST::LlvmInlineAsm &expr)
1012 : {
1013 4 : return outputs.size () == 0 && inputs.size () <= 1
1014 2 : && expr.get_clobbers ().size () <= 1
1015 2 : && expr.get_templates ().size () == 1
1016 4 : && expr.get_templates ()[0].symbol == "";
1017 : }
1018 :
1019 : } // namespace
1020 :
1021 : void
1022 2 : ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr)
1023 : {
1024 2 : auto crate_num = mappings.get_current_crate ();
1025 4 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
1026 2 : mappings.get_next_hir_id (crate_num),
1027 2 : mappings.get_next_localdef_id (crate_num));
1028 :
1029 2 : std::vector<LlvmOperand> inputs;
1030 2 : inputs.reserve (expr.get_inputs ().size ());
1031 :
1032 2 : std::vector<LlvmOperand> outputs;
1033 2 : outputs.reserve (expr.get_outputs ().size ());
1034 :
1035 4 : for (auto i : expr.get_inputs ())
1036 : {
1037 2 : std::unique_ptr<Expr> inner_expr
1038 2 : = std::unique_ptr<Expr> (translate (*i.expr.get ()));
1039 2 : inputs.emplace_back (i.constraint, std::move (inner_expr));
1040 4 : }
1041 :
1042 2 : for (auto o : expr.get_outputs ())
1043 : {
1044 0 : std::unique_ptr<Expr> inner_expr
1045 0 : = std::unique_ptr<Expr> (translate (*o.expr.get ()));
1046 0 : outputs.emplace_back (o.constraint, std::move (inner_expr));
1047 0 : }
1048 :
1049 2 : HIR::LlvmInlineAsm::Options options{expr.is_volatile (),
1050 2 : expr.is_stack_aligned (),
1051 2 : expr.get_dialect ()};
1052 :
1053 2 : if (!check_llvm_asm_support (inputs, outputs, expr))
1054 : {
1055 0 : rust_error_at (expr.get_locus (), "unsupported %qs construct",
1056 : "llvm_asm");
1057 0 : rust_inform (
1058 0 : expr.get_locus (),
1059 : "%<llvm_asm%> has been replaced with %<asm%>, gccrs only supports a "
1060 : "subset of %<llvm_asm%> to compile libcore");
1061 : }
1062 :
1063 2 : translated
1064 4 : = new HIR::LlvmInlineAsm (expr.get_locus (), inputs, outputs,
1065 2 : expr.get_templates (), expr.get_clobbers (),
1066 2 : options, expr.get_outer_attrs (), mapping);
1067 2 : }
1068 :
1069 : void
1070 0 : ASTLoweringExpr::visit (AST::FormatArgs &fmt)
1071 : {
1072 0 : rust_sorry_at (fmt.get_locus (),
1073 : "FormatArgs lowering is not implemented yet");
1074 0 : }
1075 :
1076 : void
1077 15 : ASTLoweringExpr::visit (AST::OffsetOf &offset_of)
1078 : {
1079 15 : auto type = std::unique_ptr<Type> (
1080 15 : ASTLoweringType::translate (offset_of.get_type ()));
1081 :
1082 15 : auto crate_num = mappings.get_current_crate ();
1083 30 : Analysis::NodeMapping mapping (crate_num, offset_of.get_node_id (),
1084 15 : mappings.get_next_hir_id (crate_num),
1085 15 : mappings.get_next_localdef_id (crate_num));
1086 :
1087 15 : translated = new HIR::OffsetOf (std::move (type), offset_of.get_field (),
1088 15 : mapping, offset_of.get_locus ());
1089 15 : }
1090 :
1091 : } // namespace HIR
1092 : } // namespace Rust
|
