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