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