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 125566 : ASTLoweringExpr::ASTLoweringExpr ()
37 125566 : : ASTLoweringBase (), translated (nullptr), translated_array_elems (nullptr),
38 125566 : terminated (false)
39 125566 : {}
40 :
41 : HIR::Expr *
42 125566 : ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated)
43 : {
44 125566 : ASTLoweringExpr resolver;
45 125566 : expr.accept_vis (resolver);
46 125566 : 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 125566 : resolver.mappings.insert_hir_expr (resolver.translated);
54 125566 : resolver.mappings.insert_location (
55 125566 : resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
56 :
57 125566 : if (terminated != nullptr)
58 29808 : *terminated = resolver.terminated;
59 :
60 125566 : return resolver.translated;
61 125566 : }
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 574 : ASTLoweringExpr::visit (AST::TupleExpr &expr)
82 : {
83 574 : std::vector<std::unique_ptr<HIR::Expr>> tuple_elements;
84 574 : tuple_elements.reserve (expr.get_tuple_elems ().size ());
85 :
86 1576 : for (auto &e : expr.get_tuple_elems ())
87 1002 : tuple_elements.emplace_back (ASTLoweringExpr::translate (*e));
88 :
89 574 : auto crate_num = mappings.get_current_crate ();
90 1148 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
91 574 : mappings.get_next_hir_id (crate_num),
92 574 : UNKNOWN_LOCAL_DEFID);
93 :
94 574 : translated
95 574 : = new HIR::TupleExpr (std::move (mapping), std::move (tuple_elements),
96 1148 : expr.get_inner_attrs (), expr.get_outer_attrs (),
97 574 : expr.get_locus ());
98 574 : }
99 :
100 : void
101 1243 : ASTLoweringExpr::visit (AST::IfExpr &expr)
102 : {
103 1243 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
104 1243 : }
105 :
106 : void
107 909 : ASTLoweringExpr::visit (AST::IfExprConseqElse &expr)
108 : {
109 909 : translated = ASTLoweringIfBlock::translate (expr, &terminated);
110 909 : }
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 1617 : ASTLoweringExpr::visit (AST::BlockExpr &expr)
126 : {
127 1617 : translated = ASTLoweringBlock::translate (expr, &terminated);
128 1617 : }
129 :
130 : void
131 698 : ASTLoweringExpr::visit (AST::AnonConst &expr)
132 : {
133 698 : auto &mappings = Analysis::Mappings::get ();
134 698 : auto crate_num = mappings.get_current_crate ();
135 1396 : auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (),
136 : mappings.get_next_hir_id (crate_num),
137 698 : UNKNOWN_LOCAL_DEFID);
138 :
139 698 : if (expr.is_deferred ())
140 : {
141 13 : translated = new HIR::AnonConst (std::move (mapping), expr.get_locus ());
142 : }
143 : else
144 : {
145 685 : auto inner_expr = ASTLoweringExpr::translate (expr.get_inner_expr ());
146 :
147 1370 : translated = new HIR::AnonConst (std::move (mapping),
148 685 : std::unique_ptr<Expr> (inner_expr),
149 685 : expr.get_locus ());
150 : }
151 698 : }
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 3700 : ASTLoweringExpr::visit (AST::UnsafeBlockExpr &expr)
176 : {
177 3700 : translated = ASTLoweringBlock::translate (expr, &terminated);
178 3700 : }
179 :
180 : void
181 22209 : ASTLoweringExpr::visit (AST::PathInExpression &expr)
182 : {
183 22209 : translated = ASTLowerPathInExpression::translate (expr);
184 22209 : }
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 559 : ASTLoweringExpr::visit (AST::ReturnExpr &expr)
208 : {
209 559 : terminated = true;
210 559 : HIR::Expr *return_expr
211 559 : = expr.has_returned_expr ()
212 559 : ? ASTLoweringExpr::translate (expr.get_returned_expr ())
213 : : nullptr;
214 :
215 559 : auto crate_num = mappings.get_current_crate ();
216 1118 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
217 559 : mappings.get_next_hir_id (crate_num),
218 559 : UNKNOWN_LOCAL_DEFID);
219 :
220 1118 : translated = new HIR::ReturnExpr (mapping, expr.get_locus (),
221 559 : std::unique_ptr<HIR::Expr> (return_expr));
222 559 : }
223 :
224 : void
225 12682 : ASTLoweringExpr::visit (AST::CallExpr &expr)
226 : {
227 12682 : HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
228 :
229 12682 : auto const &in_params = expr.get_params ();
230 :
231 12682 : std::vector<std::unique_ptr<HIR::Expr>> params;
232 12682 : params.reserve (in_params.size ());
233 :
234 26649 : for (auto ¶m : in_params)
235 13967 : params.emplace_back (ASTLoweringExpr::translate (*param));
236 :
237 12682 : auto crate_num = mappings.get_current_crate ();
238 12682 : Analysis::NodeMapping mapping (
239 : crate_num, UNKNOWN_NODEID /* this can map back to the AST*/,
240 12682 : mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
241 :
242 12682 : translated = new HIR::CallExpr (mapping, std::unique_ptr<HIR::Expr> (func),
243 12682 : std::move (params), expr.get_outer_attrs (),
244 25364 : expr.get_locus ());
245 12682 : }
246 :
247 : void
248 3052 : ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
249 : {
250 3052 : HIR::PathExprSegment method_path
251 3052 : = lower_path_expr_seg (expr.get_method_name ());
252 :
253 3052 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
254 :
255 3052 : auto const &in_params = expr.get_params ();
256 3052 : std::vector<std::unique_ptr<HIR::Expr>> params;
257 3052 : params.reserve (in_params.size ());
258 :
259 5110 : for (auto ¶m : in_params)
260 2058 : params.emplace_back (ASTLoweringExpr::translate (*param));
261 :
262 3052 : auto crate_num = mappings.get_current_crate ();
263 6104 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
264 3052 : mappings.get_next_hir_id (crate_num),
265 3052 : UNKNOWN_LOCAL_DEFID);
266 :
267 3052 : translated
268 3052 : = new HIR::MethodCallExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
269 : method_path, std::move (params),
270 6104 : expr.get_outer_attrs (), expr.get_locus ());
271 3052 : }
272 :
273 : void
274 2501 : ASTLoweringExpr::visit (AST::AssignmentExpr &expr)
275 : {
276 2501 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
277 2501 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
278 :
279 2501 : auto crate_num = mappings.get_current_crate ();
280 5002 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
281 2501 : mappings.get_next_hir_id (crate_num),
282 2501 : UNKNOWN_LOCAL_DEFID);
283 :
284 2501 : translated
285 2501 : = new HIR::AssignmentExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
286 5002 : std::unique_ptr<HIR::Expr> (rhs),
287 2501 : expr.get_locus ());
288 2501 : }
289 :
290 : void
291 24707 : ASTLoweringExpr::visit (AST::IdentifierExpr &expr)
292 : {
293 24707 : auto crate_num = mappings.get_current_crate ();
294 49414 : Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (),
295 24707 : mappings.get_next_hir_id (crate_num),
296 24707 : UNKNOWN_LOCAL_DEFID);
297 24707 : Analysis::NodeMapping mapping2 (mapping1);
298 :
299 49414 : HIR::PathIdentSegment ident_seg (expr.get_ident ().as_string ());
300 24707 : HIR::PathExprSegment seg (mapping1, ident_seg, expr.get_locus (),
301 49414 : HIR::GenericArgs::create_empty ());
302 49414 : translated = new HIR::PathInExpression (mapping2, {seg}, expr.get_locus (),
303 49414 : false, expr.get_outer_attrs ());
304 24707 : }
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 20867 : ASTLoweringExpr::visit (AST::LiteralExpr &expr)
380 : {
381 20867 : auto crate_num = mappings.get_current_crate ();
382 41734 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
383 20867 : mappings.get_next_hir_id (crate_num),
384 20867 : UNKNOWN_LOCAL_DEFID);
385 :
386 20867 : HIR::Literal l = lower_literal (expr.get_literal ());
387 20867 : translated = new HIR::LiteralExpr (mapping, std::move (l), expr.get_locus (),
388 41734 : expr.get_outer_attrs ());
389 20867 : }
390 :
391 : void
392 3417 : ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
393 : {
394 3417 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
395 3417 : rust_assert (lhs != nullptr);
396 3417 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
397 3417 : rust_assert (rhs != nullptr);
398 :
399 3417 : auto crate_num = mappings.get_current_crate ();
400 6834 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
401 3417 : mappings.get_next_hir_id (crate_num),
402 3417 : UNKNOWN_LOCAL_DEFID);
403 :
404 6834 : translated = new HIR::ArithmeticOrLogicalExpr (
405 3417 : mapping, std::unique_ptr<HIR::Expr> (lhs), std::unique_ptr<HIR::Expr> (rhs),
406 3417 : expr.get_expr_type (), expr.get_locus ());
407 3417 : }
408 :
409 : void
410 3566 : ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
411 : {
412 3566 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
413 3566 : rust_assert (lhs != nullptr);
414 3566 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
415 3566 : rust_assert (rhs != nullptr);
416 :
417 3566 : auto crate_num = mappings.get_current_crate ();
418 7132 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
419 3566 : mappings.get_next_hir_id (crate_num),
420 3566 : UNKNOWN_LOCAL_DEFID);
421 :
422 3566 : translated
423 3566 : = new HIR::ComparisonExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
424 7132 : std::unique_ptr<HIR::Expr> (rhs),
425 3566 : expr.get_expr_type (), expr.get_locus ());
426 3566 : }
427 :
428 : void
429 405 : ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr)
430 : {
431 405 : HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
432 405 : rust_assert (lhs != nullptr);
433 405 : HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
434 405 : rust_assert (rhs != nullptr);
435 :
436 405 : auto crate_num = mappings.get_current_crate ();
437 810 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
438 405 : mappings.get_next_hir_id (crate_num),
439 405 : UNKNOWN_LOCAL_DEFID);
440 :
441 405 : translated
442 405 : = new HIR::LazyBooleanExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
443 810 : std::unique_ptr<HIR::Expr> (rhs),
444 405 : expr.get_expr_type (), expr.get_locus ());
445 405 : }
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 5293 : ASTLoweringExpr::visit (AST::TypeCastExpr &expr)
466 : {
467 5293 : HIR::Expr *expr_to_cast_to
468 5293 : = ASTLoweringExpr::translate (expr.get_casted_expr ());
469 5293 : HIR::Type *type_to_cast_to
470 5293 : = lower_type_no_bounds (expr.get_type_to_cast_to ());
471 :
472 5293 : auto crate_num = mappings.get_current_crate ();
473 10586 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
474 5293 : mappings.get_next_hir_id (crate_num),
475 5293 : UNKNOWN_LOCAL_DEFID);
476 :
477 5293 : translated
478 5293 : = new HIR::TypeCastExpr (mapping,
479 5293 : std::unique_ptr<HIR::Expr> (expr_to_cast_to),
480 10586 : std::unique_ptr<HIR::Type> (type_to_cast_to),
481 5293 : expr.get_locus ());
482 5293 : }
483 :
484 : void
485 697 : ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr)
486 : {
487 697 : ArithmeticOrLogicalOperator op;
488 697 : 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 697 : HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
525 697 : HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
526 :
527 697 : auto crate_num = mappings.get_current_crate ();
528 1394 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
529 697 : mappings.get_next_hir_id (crate_num),
530 697 : UNKNOWN_LOCAL_DEFID);
531 :
532 1394 : translated = new HIR::CompoundAssignmentExpr (
533 697 : mapping, std::unique_ptr<HIR::Expr> (asignee_expr),
534 1394 : std::unique_ptr<HIR::Expr> (value), op, expr.get_locus ());
535 697 : }
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 1382 : ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
558 : {
559 : // bit of a hack for now
560 1382 : HIR::PathInExpression *path
561 1382 : = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
562 1382 : HIR::PathInExpression copied_path (*path);
563 1382 : delete path;
564 :
565 1382 : tl::optional<std::unique_ptr<HIR::StructBase>> base = tl::nullopt;
566 1382 : 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 1382 : auto const &in_fields = struct_expr.get_fields ();
576 :
577 1382 : std::vector<std::unique_ptr<HIR::StructExprField>> fields;
578 1382 : fields.reserve (in_fields.size ());
579 :
580 3743 : for (auto &field : in_fields)
581 2361 : fields.emplace_back (ASTLowerStructExprField::translate (*field));
582 :
583 1382 : auto crate_num = mappings.get_current_crate ();
584 2764 : Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
585 1382 : mappings.get_next_hir_id (crate_num),
586 1382 : UNKNOWN_LOCAL_DEFID);
587 :
588 1382 : translated
589 1382 : = new HIR::StructExprStructFields (mapping, copied_path, std::move (fields),
590 : struct_expr.get_locus (),
591 : std::move (base),
592 1382 : struct_expr.get_inner_attrs (),
593 2827 : struct_expr.get_outer_attrs ());
594 1445 : }
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 5060 : ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
615 : {
616 5060 : HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
617 :
618 5060 : auto crate_num = mappings.get_current_crate ();
619 10120 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
620 5060 : mappings.get_next_hir_id (crate_num),
621 5060 : UNKNOWN_LOCAL_DEFID);
622 5060 : translated
623 5060 : = new HIR::FieldAccessExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
624 10120 : expr.get_field_name (), expr.get_outer_attrs (),
625 10120 : expr.get_locus ());
626 5060 : }
627 :
628 : void
629 137 : ASTLoweringExpr::visit (AST::LoopExpr &expr)
630 : {
631 137 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
632 137 : }
633 :
634 : void
635 84 : ASTLoweringExpr::visit (AST::WhileLoopExpr &expr)
636 : {
637 84 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
638 84 : }
639 :
640 : void
641 105 : ASTLoweringExpr::visit (AST::BreakExpr &expr)
642 : {
643 105 : tl::optional<HIR::Lifetime> break_label = tl::nullopt;
644 105 : if (expr.has_label ())
645 32 : break_label = lower_lifetime (expr.get_label_unchecked ().get_lifetime ());
646 :
647 105 : HIR::Expr *break_expr
648 105 : = expr.has_break_expr ()
649 105 : ? ASTLoweringExpr::translate (expr.get_break_expr_unchecked ())
650 : : nullptr;
651 :
652 105 : auto crate_num = mappings.get_current_crate ();
653 210 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
654 105 : mappings.get_next_hir_id (crate_num),
655 105 : UNKNOWN_LOCAL_DEFID);
656 :
657 105 : translated
658 105 : = new HIR::BreakExpr (mapping, expr.get_locus (), std ::move (break_label),
659 105 : std::unique_ptr<HIR::Expr> (break_expr),
660 210 : expr.get_outer_attrs ());
661 105 : }
662 :
663 : void
664 25 : ASTLoweringExpr::visit (AST::ContinueExpr &expr)
665 : {
666 25 : tl::optional<HIR::Lifetime> break_label;
667 25 : if (expr.has_label ())
668 6 : break_label = lower_lifetime (expr.get_label_unchecked ());
669 :
670 25 : auto crate_num = mappings.get_current_crate ();
671 50 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
672 25 : mappings.get_next_hir_id (crate_num),
673 25 : UNKNOWN_LOCAL_DEFID);
674 :
675 25 : translated
676 25 : = new HIR::ContinueExpr (mapping, expr.get_locus (),
677 50 : std ::move (break_label), expr.get_outer_attrs ());
678 25 : }
679 :
680 : void
681 2010 : ASTLoweringExpr::visit (AST::BorrowExpr &expr)
682 : {
683 2010 : HIR::Expr *borrow_lvalue
684 2010 : = ASTLoweringExpr::translate (expr.get_borrowed_expr ());
685 :
686 2010 : auto crate_num = mappings.get_current_crate ();
687 4020 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
688 2010 : mappings.get_next_hir_id (crate_num),
689 2010 : UNKNOWN_LOCAL_DEFID);
690 :
691 2010 : auto *borrow_expr
692 2010 : = new HIR::BorrowExpr (mapping, std::unique_ptr<HIR::Expr> (borrow_lvalue),
693 : expr.get_mutability (), expr.is_raw_borrow (),
694 2010 : expr.get_outer_attrs (), expr.get_locus ());
695 :
696 2010 : 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 : expr.get_mutability (), expr.is_raw_borrow (),
707 46 : expr.get_outer_attrs (), expr.get_locus ());
708 : }
709 :
710 2010 : translated = borrow_expr;
711 2010 : }
712 :
713 : void
714 3920 : ASTLoweringExpr::visit (AST::DereferenceExpr &expr)
715 : {
716 3920 : HIR::Expr *dref_lvalue
717 3920 : = ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
718 :
719 3920 : auto crate_num = mappings.get_current_crate ();
720 7840 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
721 3920 : mappings.get_next_hir_id (crate_num),
722 3920 : UNKNOWN_LOCAL_DEFID);
723 :
724 3920 : translated
725 3920 : = new HIR::DereferenceExpr (mapping,
726 3920 : std::unique_ptr<HIR::Expr> (dref_lvalue),
727 7840 : expr.get_outer_attrs (), expr.get_locus ());
728 3920 : }
729 :
730 : void
731 1080 : ASTLoweringExpr::visit (AST::MatchExpr &expr)
732 : {
733 1080 : translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
734 1080 : }
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 path_mapping (crate_num, mappings.get_next_node_id (),
800 7 : mappings.get_next_hir_id (crate_num),
801 7 : UNKNOWN_LOCAL_DEFID);
802 14 : Analysis::NodeMapping call_mapping (crate_num, expr.get_node_id (),
803 7 : mappings.get_next_hir_id (crate_num),
804 7 : UNKNOWN_LOCAL_DEFID);
805 :
806 7 : HIR::Expr *func
807 : = new HIR::PathInExpression (path_mapping,
808 : LangItem::Kind::RANGE_INCLUSIVE_NEW,
809 7 : expr.get_locus (), false);
810 :
811 7 : HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
812 7 : HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
813 :
814 7 : std::vector<std::unique_ptr<HIR::Expr>> params;
815 7 : params.reserve (2);
816 7 : params.emplace_back (std::unique_ptr<HIR::Expr> (range_from));
817 7 : params.emplace_back (std::unique_ptr<HIR::Expr> (range_to));
818 :
819 7 : translated
820 7 : = new HIR::CallExpr (call_mapping, std::unique_ptr<HIR::Expr> (func),
821 7 : std::move (params), expr.get_outer_attrs (),
822 14 : expr.get_locus ());
823 7 : }
824 :
825 : void
826 36 : ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
827 : {
828 36 : HIR::Expr *closure_expr
829 36 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
830 :
831 36 : std::vector<HIR::ClosureParam> closure_params;
832 36 : closure_params.reserve (expr.get_params ().size ());
833 :
834 60 : for (auto ¶m : expr.get_params ())
835 24 : closure_params.emplace_back (lower_closure_param (param));
836 :
837 36 : auto crate_num = mappings.get_current_crate ();
838 72 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
839 36 : mappings.get_next_hir_id (crate_num),
840 36 : mappings.get_next_localdef_id (crate_num));
841 :
842 36 : translated
843 36 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
844 : nullptr /* closure_return_type */,
845 36 : std::unique_ptr<HIR::Expr> (closure_expr),
846 36 : expr.get_has_move (), expr.get_outer_attrs (),
847 36 : expr.get_locus ());
848 36 : }
849 :
850 : void
851 30 : ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
852 : {
853 30 : HIR::Type *closure_return_type = nullptr;
854 30 : HIR::Expr *closure_expr
855 30 : = ASTLoweringExpr::translate (expr.get_definition_expr ());
856 :
857 30 : std::vector<HIR::ClosureParam> closure_params;
858 30 : closure_params.reserve (expr.get_params ().size ());
859 :
860 67 : for (auto ¶m : expr.get_params ())
861 37 : closure_params.emplace_back (lower_closure_param (param));
862 :
863 30 : auto crate_num = mappings.get_current_crate ();
864 60 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
865 30 : mappings.get_next_hir_id (crate_num),
866 30 : mappings.get_next_localdef_id (crate_num));
867 :
868 30 : translated
869 30 : = new HIR::ClosureExpr (mapping, std::move (closure_params),
870 90 : std::unique_ptr<HIR::Type> (closure_return_type),
871 60 : std::unique_ptr<HIR::Expr> (closure_expr),
872 30 : expr.get_has_move (), expr.get_outer_attrs (),
873 60 : expr.get_locus ());
874 30 : }
875 :
876 : HIR::InlineAsmOperand
877 10 : translate_operand_in (const AST::InlineAsmOperand &operand)
878 : {
879 10 : auto in_value = operand.get_in ();
880 :
881 10 : struct HIR::InlineAsmOperand::In in (
882 : in_value.reg,
883 10 : std::unique_ptr<Expr> (ASTLoweringExpr::translate (*in_value.expr.get ())));
884 10 : return in;
885 10 : }
886 :
887 : HIR::InlineAsmOperand
888 17 : translate_operand_out (const AST::InlineAsmOperand &operand)
889 : {
890 17 : auto out_value = operand.get_out ();
891 17 : struct HIR::InlineAsmOperand::Out out (out_value.reg, out_value.late,
892 17 : std::unique_ptr<Expr> (
893 : ASTLoweringExpr::translate (
894 17 : *out_value.expr.get ())));
895 17 : return out;
896 17 : }
897 :
898 : HIR::InlineAsmOperand
899 0 : translate_operand_inout (const AST::InlineAsmOperand &operand)
900 : {
901 0 : auto inout_value = operand.get_in_out ();
902 0 : struct HIR::InlineAsmOperand::InOut inout (inout_value.reg, inout_value.late,
903 0 : std::unique_ptr<Expr> (
904 : ASTLoweringExpr::translate (
905 0 : *inout_value.expr.get ())));
906 0 : return inout;
907 0 : }
908 :
909 : HIR::InlineAsmOperand
910 2 : translate_operand_split_in_out (const AST::InlineAsmOperand &operand)
911 : {
912 2 : auto split_in_out_value = operand.get_split_in_out ();
913 2 : struct HIR::InlineAsmOperand::SplitInOut split_in_out (
914 : split_in_out_value.reg, split_in_out_value.late,
915 2 : std::unique_ptr<Expr> (
916 2 : ASTLoweringExpr::translate (*split_in_out_value.in_expr.get ())),
917 2 : std::unique_ptr<Expr> (
918 2 : ASTLoweringExpr::translate (*split_in_out_value.out_expr.get ())));
919 2 : return split_in_out;
920 2 : }
921 :
922 : HIR::InlineAsmOperand
923 0 : translate_operand_const (const AST::InlineAsmOperand &operand)
924 : {
925 0 : auto const_value = operand.get_const ();
926 :
927 0 : auto inner_expr = ASTLoweringExpr::translate (const_value.anon_const);
928 :
929 : // Like `ConstBlock`, we know this should only be an `AnonConst` - let's
930 : // assert to make sure and static cast
931 0 : rust_assert (inner_expr->get_expression_type () == Expr::ExprType::AnonConst);
932 :
933 0 : auto anon_const = static_cast<AnonConst *> (inner_expr);
934 :
935 0 : return HIR::InlineAsmOperand::Const{*anon_const};
936 0 : }
937 :
938 : HIR::InlineAsmOperand
939 0 : translate_operand_sym (const AST::InlineAsmOperand &operand)
940 : {
941 0 : auto sym_value = operand.get_sym ();
942 0 : struct HIR::InlineAsmOperand::Sym sym (std::unique_ptr<Expr> (
943 0 : ASTLoweringExpr::translate (*sym_value.expr.get ())));
944 0 : return sym;
945 0 : }
946 : HIR::InlineAsmOperand
947 0 : translate_operand_label (const AST::InlineAsmOperand &operand)
948 : {
949 0 : auto label_value = operand.get_label ();
950 0 : struct HIR::InlineAsmOperand::Label label (label_value.label_name,
951 0 : std::unique_ptr<Expr> (
952 : ASTLoweringExpr::translate (
953 0 : *label_value.expr.get ())));
954 0 : return label;
955 0 : }
956 : HIR::InlineAsmOperand
957 29 : from_operand (const AST::InlineAsmOperand &operand)
958 : {
959 29 : using RegisterType = AST::InlineAsmOperand::RegisterType;
960 29 : auto type = operand.get_register_type ();
961 :
962 : /*In,*/
963 : /*Out,*/
964 : /*InOut,*/
965 : /*SplitInOut,*/
966 : /*Const,*/
967 : /*Sym,*/
968 : /*Label,*/
969 29 : switch (type)
970 : {
971 10 : case RegisterType::In:
972 10 : return translate_operand_in (operand);
973 17 : case RegisterType::Out:
974 17 : return translate_operand_out (operand);
975 0 : case RegisterType::InOut:
976 0 : return translate_operand_inout (operand);
977 2 : case RegisterType::SplitInOut:
978 2 : return translate_operand_split_in_out (operand);
979 0 : case RegisterType::Const:
980 0 : return translate_operand_const (operand);
981 0 : case RegisterType::Sym:
982 0 : return translate_operand_sym (operand);
983 0 : case RegisterType::Label:
984 0 : return translate_operand_label (operand);
985 0 : default:
986 0 : rust_unreachable ();
987 : }
988 : }
989 : void
990 27 : ASTLoweringExpr::visit (AST::InlineAsm &expr)
991 : {
992 27 : auto crate_num = mappings.get_current_crate ();
993 54 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
994 27 : mappings.get_next_hir_id (crate_num),
995 27 : mappings.get_next_localdef_id (crate_num));
996 :
997 27 : std::vector<HIR::InlineAsmOperand> hir_operands;
998 27 : const std::vector<AST::InlineAsmOperand> &ast_operands = expr.get_operands ();
999 : /*int ast_operands_size = ast_operands.size ();*/
1000 56 : for (auto &operand : ast_operands)
1001 : {
1002 29 : hir_operands.push_back (from_operand (operand));
1003 : }
1004 : /*int hir_operands_size = hir_operands.size ();*/
1005 :
1006 : /*rust_debug ("{bdbt} : There are %d ast operands prelowering and %d hir "*/
1007 : /* "operands after lowering\n",*/
1008 : /* ast_operands_size, hir_operands_size);*/
1009 27 : translated
1010 54 : = new HIR::InlineAsm (expr.get_locus (), expr.is_global_asm,
1011 54 : expr.get_template_ (), expr.get_template_strs (),
1012 27 : hir_operands, expr.get_clobber_abi (),
1013 108 : expr.get_options (), mapping);
1014 27 : }
1015 :
1016 : namespace {
1017 : // We're not really supporting llvm_asm, only the bare minimum for libcore's
1018 : // blackbox
1019 : // llvm_asm!("" : : "r"(&mut dummy) : "memory" : "volatile");
1020 : bool
1021 2 : check_llvm_asm_support (const std::vector<LlvmOperand> &inputs,
1022 : const std::vector<LlvmOperand> &outputs,
1023 : const AST::LlvmInlineAsm &expr)
1024 : {
1025 4 : return outputs.size () == 0 && inputs.size () <= 1
1026 2 : && expr.get_clobbers ().size () <= 1
1027 2 : && expr.get_templates ().size () == 1
1028 4 : && expr.get_templates ()[0].symbol == "";
1029 : }
1030 :
1031 : } // namespace
1032 :
1033 : void
1034 2 : ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr)
1035 : {
1036 2 : auto crate_num = mappings.get_current_crate ();
1037 4 : Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
1038 2 : mappings.get_next_hir_id (crate_num),
1039 2 : mappings.get_next_localdef_id (crate_num));
1040 :
1041 2 : std::vector<LlvmOperand> inputs;
1042 2 : inputs.reserve (expr.get_inputs ().size ());
1043 :
1044 2 : std::vector<LlvmOperand> outputs;
1045 2 : outputs.reserve (expr.get_outputs ().size ());
1046 :
1047 4 : for (auto i : expr.get_inputs ())
1048 : {
1049 2 : std::unique_ptr<Expr> inner_expr
1050 2 : = std::unique_ptr<Expr> (translate (*i.expr.get ()));
1051 2 : inputs.emplace_back (i.constraint, std::move (inner_expr));
1052 4 : }
1053 :
1054 2 : for (auto o : expr.get_outputs ())
1055 : {
1056 0 : std::unique_ptr<Expr> inner_expr
1057 0 : = std::unique_ptr<Expr> (translate (*o.expr.get ()));
1058 0 : outputs.emplace_back (o.constraint, std::move (inner_expr));
1059 0 : }
1060 :
1061 2 : HIR::LlvmInlineAsm::Options options{expr.is_volatile (),
1062 2 : expr.is_stack_aligned (),
1063 2 : expr.get_dialect ()};
1064 :
1065 2 : if (!check_llvm_asm_support (inputs, outputs, expr))
1066 : {
1067 0 : rust_error_at (expr.get_locus (), "unsupported %qs construct",
1068 : "llvm_asm");
1069 0 : rust_inform (
1070 0 : expr.get_locus (),
1071 : "%<llvm_asm%> has been replaced with %<asm%>, gccrs only supports a "
1072 : "subset of %<llvm_asm%> to compile libcore");
1073 : }
1074 :
1075 2 : translated
1076 4 : = new HIR::LlvmInlineAsm (expr.get_locus (), inputs, outputs,
1077 2 : expr.get_templates (), expr.get_clobbers (),
1078 2 : options, expr.get_outer_attrs (), mapping);
1079 2 : }
1080 :
1081 : void
1082 0 : ASTLoweringExpr::visit (AST::FormatArgs &fmt)
1083 : {
1084 0 : rust_sorry_at (fmt.get_locus (),
1085 : "FormatArgs lowering is not implemented yet");
1086 0 : }
1087 :
1088 : void
1089 15 : ASTLoweringExpr::visit (AST::OffsetOf &offset_of)
1090 : {
1091 15 : auto type = std::unique_ptr<Type> (
1092 15 : ASTLoweringType::translate (offset_of.get_type ()));
1093 :
1094 15 : auto crate_num = mappings.get_current_crate ();
1095 30 : Analysis::NodeMapping mapping (crate_num, offset_of.get_node_id (),
1096 15 : mappings.get_next_hir_id (crate_num),
1097 15 : mappings.get_next_localdef_id (crate_num));
1098 :
1099 15 : translated = new HIR::OffsetOf (std::move (type), offset_of.get_field (),
1100 15 : mapping, offset_of.get_locus ());
1101 15 : }
1102 :
1103 : } // namespace HIR
1104 : } // namespace Rust
|
