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