Branch data Line data Source code
1 : : // Copyright (C) 2020-2024 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-hir-dump.h"
20 : : #include "rust-abi.h"
21 : : #include "rust-hir-item.h"
22 : : #include "rust-hir-path.h"
23 : : #include "rust-hir-type.h"
24 : : #include "rust-hir.h"
25 : : #include <string>
26 : : #include "rust-attribute-values.h"
27 : :
28 : : namespace Rust {
29 : : namespace HIR {
30 : :
31 : : // Dump Format for HIR
32 : : //
33 : : // SomeHIRNode [
34 : : // field: ...
35 : : // field: ...
36 : : // field: ...
37 : : // ]
38 : : //
39 : : // When a field is a collection of other HIR objects:
40 : : // field {
41 : : // SomeHIRNode [ ... ]
42 : : // SomeOtherHIRNode [ ... ]
43 : : // }
44 : : //
45 : : // If a field is an empty collection:
46 : : // field: empty
47 : : //
48 : : // If a field is optional and is currently not holding anything:
49 : : // field: none
50 : :
51 : : std::string Dump::delims[2][2] = {
52 : : {std::string ("{"), std::string ("}")},
53 : : {std::string ("["), std::string ("]")},
54 : : };
55 : :
56 : : static std::string
57 : 0 : BoundPolarityString (BoundPolarity polarity)
58 : : {
59 : 0 : switch (polarity)
60 : : {
61 : 0 : case RegularBound:
62 : 0 : return "regular";
63 : 0 : case NegativeBound:
64 : 0 : return "negative";
65 : 0 : case AntiBound:
66 : 0 : return "anti";
67 : : }
68 : 0 : return "unknown";
69 : : }
70 : :
71 : : /**
72 : : * Static member used to dump HIR from the debugger to stderr.
73 : : *
74 : : * @param v The HIR node to dump
75 : : */
76 : : void
77 : 0 : Dump::debug (FullVisitable &v)
78 : : {
79 : 0 : Dump dump (std::cerr);
80 : 0 : v.accept_vis (dump);
81 : 0 : }
82 : :
83 : : void
84 : 0 : Dump::go (HIR::Crate &e)
85 : : {
86 : 0 : begin ("Crate");
87 : 0 : do_inner_attrs (e);
88 : 0 : do_mappings (e.get_mappings ());
89 : :
90 : 0 : visit_collection ("items", e.get_items ());
91 : 0 : end ("Crate");
92 : 0 : }
93 : :
94 : 0 : Dump::Dump (std::ostream &stream) : stream (stream) {}
95 : :
96 : : /**
97 : : * Writes TEXT with a final newline if ENDLINE is true.
98 : : * If TEXT is starting the current line, its first line is indented.
99 : : * If TEXT is multiline, all followning lines are also indented.
100 : : *
101 : : * @param text Text to emit
102 : : * @param endline If true, newline is emitted after text
103 : : */
104 : : void
105 : 0 : Dump::put (std::string text, bool endline)
106 : : {
107 : 0 : if (beg_of_line)
108 : : {
109 : 0 : stream << indentation;
110 : 0 : beg_of_line = false;
111 : : }
112 : :
113 : : // keep multiline string indented
114 : 0 : std::string::size_type pos = 0;
115 : : std::string::size_type prev = 0;
116 : : auto first = true;
117 : 0 : while ((pos = text.find ('\n', prev)) != std::string::npos)
118 : : {
119 : 0 : if (!first)
120 : 0 : stream << std::endl << indentation;
121 : 0 : first = false;
122 : :
123 : 0 : stream << text.substr (prev, pos - prev);
124 : 0 : prev = pos + 1;
125 : : }
126 : :
127 : 0 : if (first)
128 : 0 : stream << text;
129 : :
130 : 0 : if (endline)
131 : : {
132 : 0 : stream << std::endl;
133 : 0 : beg_of_line = endline;
134 : : }
135 : 0 : }
136 : :
137 : : /**
138 : : * Called when starting to emit info for an HIR node.
139 : : * Emits NAME and an opening delimiter denoted by D.
140 : : *
141 : : * @param name Name of HIR node
142 : : * @param d Delimiter
143 : : */
144 : : void
145 : 0 : Dump::begin (std::string name, enum delim d)
146 : : {
147 : 0 : if (!beg_of_line)
148 : 0 : put ("");
149 : 0 : put (name + " " + delims[d][0], true);
150 : 0 : indentation.increment ();
151 : 0 : }
152 : :
153 : : /**
154 : : * Called when ending the dump info for an HIR node. Emits a C++-style
155 : : * comment with NAME and a closing delimiter denoted by D.
156 : : *
157 : : * @param name Name of HIR node
158 : : * @param d Delimiter
159 : : */
160 : : void
161 : 0 : Dump::end (std::string name, enum delim d)
162 : : {
163 : 0 : indentation.decrement ();
164 : 0 : if (!beg_of_line)
165 : 0 : stream << std::endl;
166 : 0 : put (delims[d][1] + " // " + name);
167 : 0 : }
168 : :
169 : : /**
170 : : * Called when starting to emit info for a field within an HIR node.
171 : : * Emits NAME and an opening curly brace
172 : : *
173 : : * @param name HIR field name
174 : : */
175 : : void
176 : 0 : Dump::begin_field (std::string name)
177 : : {
178 : 0 : begin (name, CURLY);
179 : 0 : }
180 : :
181 : : /**
182 : : * Called when ending the dump info for a field within an HIR node.
183 : : * Emits a C++-style comment with NAME and a closing curly brace
184 : : *
185 : : * @param name HIR field name
186 : : */
187 : : void
188 : 0 : Dump::end_field (std::string name)
189 : : {
190 : 0 : end (name, CURLY);
191 : 0 : }
192 : :
193 : : /**
194 : : * Emits a single field/value pair denoted by NAME and TEXT.
195 : : *
196 : : * @param name Field name
197 : : * @param text Field value
198 : : */
199 : : void
200 : 0 : Dump::put_field (std::string name, std::string text)
201 : : {
202 : 0 : put (name + ": ", false);
203 : 0 : indentation.increment ();
204 : 0 : put (text);
205 : 0 : indentation.decrement ();
206 : 0 : }
207 : :
208 : : /**
209 : : * Recursively visits an HIR field NAME with value possibly pointed to by
210 : : * PTR, if PTR is not null. If PTR is null, simply emits FIELD_NAME/NULL pair.
211 : : *
212 : : * @param name Field name
213 : : * @param ptr Pointer to field's value
214 : : */
215 : : template <class T>
216 : : void
217 : 0 : Dump::visit_field (std::string name, std::unique_ptr<T> &ptr)
218 : : {
219 : 0 : if (ptr)
220 : 0 : visit_field (name, *ptr);
221 : : else
222 : 0 : put_field (name, "NULL");
223 : 0 : }
224 : :
225 : : /**
226 : : * Recursively visits an HIR field NAME with value V.
227 : : *
228 : : * @param name Field name
229 : : * @param v Field value
230 : : */
231 : : void
232 : 0 : Dump::visit_field (std::string name, FullVisitable &v)
233 : : {
234 : 0 : put (name + ": ", false);
235 : 0 : indentation.increment ();
236 : 0 : v.accept_vis (*this);
237 : 0 : indentation.decrement ();
238 : 0 : }
239 : :
240 : : /**
241 : : * Recursively visits a collection VEC of HIR node for field NAME.
242 : : * If VEC is empty, simply emits the NAME/empty pair.
243 : : *
244 : : * @param name Field name
245 : : * @param vec Field value as a vector
246 : : */
247 : : template <class T>
248 : : void
249 : 0 : Dump::visit_collection (std::string name, std::vector<std::unique_ptr<T>> &vec)
250 : : {
251 : 0 : if (vec.empty ())
252 : : {
253 : 0 : put_field (name, "empty");
254 : 0 : return;
255 : : }
256 : :
257 : 0 : begin_field (name);
258 : 0 : for (const auto &elt : vec)
259 : 0 : elt->accept_vis (*this);
260 : 0 : end_field (name);
261 : : }
262 : :
263 : : /**
264 : : * Recursively visits a collection VEC of HIR node for field NAME.
265 : : * If VEC is empty, simply emits the NAME/empty pair.
266 : : *
267 : : * @param name Field name
268 : : * @param vec Field value as a vector
269 : : */
270 : : template <class T>
271 : : void
272 : 0 : Dump::visit_collection (std::string name, std::vector<T> &vec)
273 : : {
274 : 0 : if (vec.empty ())
275 : : {
276 : 0 : put_field (name, "empty");
277 : 0 : return;
278 : : }
279 : :
280 : 0 : begin_field (name);
281 : 0 : for (auto &elt : vec)
282 : 0 : elt.accept_vis (*this);
283 : 0 : end_field (name);
284 : : }
285 : :
286 : : void
287 : 0 : Dump::do_traititem (TraitItem &e)
288 : : {
289 : 0 : do_mappings (e.get_mappings ());
290 : 0 : auto oa = e.get_outer_attrs ();
291 : 0 : do_outer_attrs (oa);
292 : 0 : }
293 : :
294 : : void
295 : 0 : Dump::do_vis_item (VisItem &e)
296 : : {
297 : 0 : do_item (e);
298 : 0 : std::string str = "none";
299 : 0 : if (e.has_visibility ())
300 : 0 : str = e.get_visibility ().as_string ();
301 : 0 : put_field ("visibility", str);
302 : 0 : }
303 : :
304 : : void
305 : 0 : Dump::do_functionparam (FunctionParam &e)
306 : : {
307 : 0 : begin ("FunctionParam");
308 : 0 : do_mappings (e.get_mappings ());
309 : 0 : visit_field ("param_name", e.get_param_name ());
310 : 0 : visit_field ("type", e.get_type ());
311 : 0 : end ("FunctionParam");
312 : 0 : }
313 : :
314 : : void
315 : 0 : Dump::do_pathpattern (PathPattern &e)
316 : : {
317 : 0 : std::string str = "";
318 : :
319 : 0 : for (const auto &segment : e.get_segments ())
320 : 0 : str += segment.as_string () + ", ";
321 : :
322 : 0 : put_field ("segments", str);
323 : 0 : }
324 : :
325 : : void
326 : 0 : Dump::do_structexprstruct (StructExprStruct &e)
327 : : {
328 : 0 : do_expr (e);
329 : :
330 : : // StructExpr
331 : 0 : visit_field ("struct_name", e.get_struct_name ());
332 : :
333 : : // StructExprStruct
334 : 0 : do_mappings (e.get_mappings ());
335 : 0 : do_inner_attrs (e);
336 : 0 : }
337 : :
338 : : void
339 : 0 : Dump::do_ifexpr (IfExpr &e)
340 : : {
341 : 0 : do_expr (e);
342 : 0 : visit_field ("condition", e.get_if_condition ());
343 : 0 : visit_field ("if_block", e.get_if_block ());
344 : 0 : }
345 : :
346 : : void
347 : 0 : Dump::do_expr (Expr &e)
348 : : {
349 : 0 : do_mappings (e.get_mappings ());
350 : 0 : auto oa = e.get_outer_attrs ();
351 : 0 : do_outer_attrs (oa);
352 : 0 : }
353 : :
354 : : void
355 : 0 : Dump::do_pathexpr (PathExpr &e)
356 : : {
357 : 0 : do_expr (e);
358 : 0 : }
359 : :
360 : : void
361 : 0 : Dump::do_typepathsegment (TypePathSegment &e)
362 : : {
363 : 0 : do_mappings (e.get_mappings ());
364 : 0 : put_field ("ident_segment", e.get_ident_segment ().as_string ());
365 : 0 : }
366 : :
367 : : void
368 : 0 : Dump::do_typepathfunction (TypePathFunction &e)
369 : : {
370 : 0 : visit_collection ("params", e.get_params ());
371 : 0 : visit_field ("return_type", e.get_return_type ());
372 : 0 : }
373 : :
374 : : void
375 : 0 : Dump::do_qualifiedpathtype (QualifiedPathType &e)
376 : : {
377 : 0 : do_mappings (e.get_mappings ());
378 : 0 : visit_field ("type", e.get_type ());
379 : :
380 : 0 : visit_field ("trait", e.get_trait ());
381 : 0 : }
382 : :
383 : : void
384 : 0 : Dump::do_operatorexpr (OperatorExpr &e)
385 : : {
386 : 0 : visit_field ("main_or_left_expr", e.get_expr ());
387 : 0 : }
388 : :
389 : : void
390 : 0 : Dump::do_mappings (const Analysis::NodeMapping &mappings)
391 : : {
392 : 0 : put ("mapping: ", false);
393 : 0 : put (mappings.as_string ());
394 : 0 : }
395 : :
396 : : void
397 : 0 : Dump::do_inner_attrs (WithInnerAttrs &e)
398 : : {
399 : 0 : auto attrs = e.get_inner_attrs ();
400 : :
401 : 0 : if (attrs.empty ())
402 : : {
403 : 0 : put_field ("inner_attrs", "empty");
404 : 0 : return;
405 : : }
406 : :
407 : 0 : begin_field ("inner_attrs");
408 : 0 : for (auto &elt : attrs)
409 : 0 : visit (elt);
410 : 0 : end_field ("inner_attrs");
411 : 0 : }
412 : :
413 : : void
414 : 0 : Dump::do_outer_attrs (std::vector<AST::Attribute> &attrs)
415 : : {
416 : 0 : if (attrs.empty ())
417 : 0 : put_field ("outer_attributes", "empty");
418 : : else
419 : : {
420 : 0 : begin_field ("outer_attributes");
421 : 0 : for (const auto &attr : attrs)
422 : 0 : put (attr.as_string ());
423 : 0 : end_field ("outer_attributes");
424 : : }
425 : 0 : }
426 : :
427 : : void
428 : 0 : Dump::do_baseloopexpr (BaseLoopExpr &e)
429 : : {
430 : 0 : do_expr (e);
431 : :
432 : 0 : if (!e.has_loop_label ())
433 : 0 : put_field ("label", "none");
434 : : else
435 : 0 : put_field ("label", e.get_loop_label ().as_string ());
436 : :
437 : 0 : visit_field ("loop_block", e.get_loop_block ());
438 : 0 : }
439 : :
440 : : void
441 : 0 : Dump::do_ifletexpr (IfLetExpr &e)
442 : : {
443 : 0 : do_expr (e);
444 : :
445 : 0 : visit_collection ("match_arm_patterns", e.get_patterns ());
446 : :
447 : 0 : visit_field ("value", e.get_scrutinee_expr ());
448 : 0 : visit_field ("if_block", e.get_if_block ());
449 : 0 : }
450 : :
451 : : void
452 : 0 : Dump::do_struct (Struct &e)
453 : : {
454 : 0 : do_vis_item (e);
455 : 0 : put_field ("struct_name", e.get_identifier ().as_string ());
456 : 0 : visit_collection ("generic_params", e.get_generic_params ());
457 : :
458 : 0 : if (!e.has_where_clause ())
459 : 0 : put_field ("where_clause", "none");
460 : : else
461 : 0 : put_field ("where clause", e.get_where_clause ().as_string ());
462 : 0 : }
463 : :
464 : : void
465 : 0 : Dump::do_enumitem (EnumItem &e)
466 : : {
467 : 0 : do_item (e);
468 : :
469 : 0 : put_field ("variant_name", e.get_identifier ().as_string ());
470 : :
471 : 0 : std::string str;
472 : 0 : switch (e.get_enum_item_kind ())
473 : : {
474 : 0 : case EnumItem::EnumItemKind::Named:
475 : 0 : str = "[Named variant]";
476 : 0 : break;
477 : 0 : case EnumItem::EnumItemKind::Tuple:
478 : 0 : str = "[Tuple variant]";
479 : 0 : break;
480 : 0 : case EnumItem::EnumItemKind::Struct:
481 : 0 : str = "[Struct variant]";
482 : 0 : break;
483 : 0 : case EnumItem::EnumItemKind::Discriminant:
484 : 0 : str = "[Discriminant variant]";
485 : 0 : break;
486 : : }
487 : 0 : put_field ("item_kind", str);
488 : 0 : }
489 : :
490 : : void
491 : 0 : Dump::do_traitfunctiondecl (TraitFunctionDecl &e)
492 : : {
493 : 0 : begin ("TraitFunctionDecl");
494 : 0 : put_field ("qualifiers", e.get_qualifiers ().as_string ());
495 : 0 : put_field ("function_name", e.get_function_name ().as_string ());
496 : 0 : visit_collection ("generic_params", e.get_generic_params ());
497 : :
498 : 0 : if (!e.get_function_params ().empty ())
499 : : {
500 : 0 : begin_field ("function_params");
501 : 0 : for (auto &item : e.get_function_params ())
502 : 0 : do_functionparam (item);
503 : 0 : end_field ("function_params");
504 : : }
505 : : else
506 : 0 : put_field ("function_params", "empty");
507 : :
508 : 0 : visit_field ("return_type", e.get_return_type ());
509 : :
510 : 0 : if (e.has_where_clause ())
511 : 0 : put_field ("where_clause", e.get_where_clause ().as_string ());
512 : : else
513 : 0 : put_field ("where_clause", "none");
514 : :
515 : 0 : put_field ("self", e.get_self ().as_string ());
516 : :
517 : 0 : end ("TraitFunctionDecl");
518 : 0 : }
519 : :
520 : : void
521 : 0 : Dump::do_externalitem (ExternalItem &e)
522 : : {
523 : 0 : do_mappings (e.get_mappings ());
524 : :
525 : 0 : auto oa = e.get_outer_attrs ();
526 : 0 : do_outer_attrs (oa);
527 : :
528 : 0 : std::string str = "none";
529 : 0 : if (e.has_visibility ())
530 : 0 : str = e.get_visibility ().as_string ();
531 : 0 : put_field ("visibility", str);
532 : 0 : put_field ("item_name", e.get_item_name ().as_string ());
533 : 0 : }
534 : :
535 : : void
536 : 0 : Dump::do_namefunctionparam (NamedFunctionParam &e)
537 : : {
538 : 0 : begin ("NamedFunctionParam");
539 : 0 : do_mappings (e.get_mappings ());
540 : 0 : put_field ("name", e.get_param_name ().as_string ());
541 : 0 : visit_field ("type", e.get_type ());
542 : 0 : end ("NamedFunctionParam");
543 : 0 : }
544 : :
545 : : void
546 : 0 : Dump::do_stmt (Stmt &e)
547 : : {
548 : 0 : do_mappings (e.get_mappings ());
549 : 0 : }
550 : :
551 : : void
552 : 0 : Dump::do_type (Type &e)
553 : : {
554 : 0 : do_mappings (e.get_mappings ());
555 : 0 : }
556 : :
557 : : void
558 : 0 : Dump::do_item (Item &e)
559 : : {
560 : 0 : do_stmt (e);
561 : 0 : auto oa = e.get_outer_attrs ();
562 : 0 : do_outer_attrs (oa);
563 : 0 : }
564 : :
565 : : void
566 : 0 : Dump::do_tuplefield (TupleField &e)
567 : : {
568 : 0 : do_mappings (e.get_mappings ());
569 : 0 : auto oa = e.get_outer_attrs ();
570 : 0 : do_outer_attrs (oa);
571 : :
572 : 0 : std::string str = "none";
573 : 0 : if (e.has_visibility ())
574 : 0 : str = e.get_visibility ().as_string ();
575 : 0 : put_field ("visibility", str);
576 : :
577 : 0 : visit_field ("field_type", e.get_field_type ());
578 : 0 : }
579 : :
580 : : void
581 : 0 : Dump::do_structfield (StructField &e)
582 : : {
583 : 0 : do_mappings (e.get_mappings ());
584 : 0 : auto oa = e.get_outer_attrs ();
585 : 0 : do_outer_attrs (oa);
586 : :
587 : 0 : std::string str = "none";
588 : 0 : if (e.has_visibility ())
589 : 0 : str = e.get_visibility ().as_string ();
590 : 0 : put_field ("visibility", str);
591 : 0 : put_field ("field_name", e.get_field_name ().as_string ());
592 : 0 : visit_field ("field_type", e.get_field_type ());
593 : 0 : }
594 : :
595 : : void
596 : 0 : Dump::do_genericargs (GenericArgs &e)
597 : : {
598 : 0 : visit_collection ("lifetime_args", e.get_lifetime_args ());
599 : 0 : visit_collection ("type_args", e.get_type_args ());
600 : :
601 : 0 : if (e.get_const_args ().empty ())
602 : : {
603 : 0 : put_field ("binding_args", "empty");
604 : : }
605 : : else
606 : : {
607 : 0 : begin_field ("const_args");
608 : 0 : for (auto &arg : e.get_const_args ())
609 : : {
610 : 0 : begin ("ConstGenericArg");
611 : 0 : visit_field ("expression", arg.get_expression ());
612 : 0 : end ("ConstGenericArg");
613 : : }
614 : 0 : end_field ("const_args");
615 : : }
616 : :
617 : 0 : if (e.get_binding_args ().empty ())
618 : : {
619 : 0 : put_field ("binding_args", "empty");
620 : : }
621 : : else
622 : : {
623 : 0 : begin_field ("binding_args");
624 : 0 : for (auto &arg : e.get_binding_args ())
625 : : {
626 : 0 : begin ("GenericArgsBinding");
627 : 0 : put_field ("identfier", arg.get_identifier ().as_string ());
628 : 0 : visit_field ("type", arg.get_type ());
629 : 0 : end ("GenericArgsBinding");
630 : : }
631 : 0 : end_field ("binding_args");
632 : : }
633 : 0 : }
634 : :
635 : : void
636 : 0 : Dump::do_maybenamedparam (MaybeNamedParam &e)
637 : : {
638 : 0 : visit_field ("param_type", e.get_type ());
639 : 0 : put_field ("param_kind", enum_to_str (e.get_param_kind ()));
640 : 0 : put_field ("name", e.get_name ().as_string ());
641 : 0 : }
642 : :
643 : : // All visit methods
644 : :
645 : : void
646 : 0 : Dump::visit (AST::Attribute &attribute)
647 : : {
648 : : // Special, no begin/end as this is called by do_inner_attrs.
649 : 0 : put_field (Values::Attributes::PATH, attribute.get_path ().as_string ());
650 : :
651 : 0 : std::string str = "none";
652 : 0 : if (attribute.has_attr_input ())
653 : 0 : str = attribute.get_attr_input ().as_string ();
654 : 0 : put_field ("attr_input", str);
655 : 0 : }
656 : :
657 : : void
658 : 0 : Dump::visit (Lifetime &e)
659 : : {
660 : 0 : do_mappings (e.get_mappings ());
661 : :
662 : 0 : std::string type;
663 : 0 : std::string name = e.get_name ();
664 : 0 : switch (e.get_lifetime_type ())
665 : : {
666 : 0 : case AST::Lifetime::LifetimeType::NAMED:
667 : 0 : type = "[NAMED]";
668 : 0 : break;
669 : 0 : case AST::Lifetime::LifetimeType::STATIC:
670 : 0 : type = "[STATIC]";
671 : 0 : name += " (not applicable for type)";
672 : 0 : break;
673 : 0 : case AST::Lifetime::LifetimeType::WILDCARD:
674 : 0 : type = "[WILDCARD]";
675 : 0 : name += " (not applicable for type)";
676 : 0 : break;
677 : 0 : default:
678 : 0 : rust_assert (false);
679 : : break;
680 : : }
681 : 0 : put_field ("lifetime_type", type);
682 : 0 : put_field ("lifetime_name", name);
683 : 0 : }
684 : :
685 : : void
686 : 0 : Dump::visit (LifetimeParam &lifetimeparam)
687 : : {
688 : 0 : begin ("Lifetimeparam");
689 : 0 : put (lifetimeparam.as_string ());
690 : 0 : end ("Lifetimeparam");
691 : 0 : }
692 : :
693 : : void
694 : 0 : Dump::visit (PathInExpression &e)
695 : : {
696 : 0 : begin ("PathInExpression");
697 : 0 : do_pathpattern (e);
698 : 0 : do_pathexpr (e);
699 : :
700 : 0 : put_field ("has_opening_scope_resolution",
701 : 0 : std::to_string (e.opening_scope_resolution ()));
702 : 0 : end ("PathInExpression");
703 : 0 : }
704 : :
705 : : void
706 : 0 : Dump::visit (TypePathSegment &e)
707 : : {
708 : 0 : begin ("TypePathSegment");
709 : 0 : do_typepathsegment (e);
710 : 0 : end ("TypePathSegment");
711 : 0 : }
712 : :
713 : : void
714 : 0 : Dump::visit (TypePathSegmentGeneric &e)
715 : : {
716 : 0 : begin ("TypePathSegmentGeneric");
717 : 0 : do_typepathsegment (e);
718 : :
719 : 0 : if (e.has_generic_args ())
720 : : {
721 : 0 : begin_field ("generic_args");
722 : 0 : begin ("GenericArgs");
723 : 0 : do_genericargs (e.get_generic_args ());
724 : 0 : end ("GenericArgs");
725 : 0 : end_field ("generic_args");
726 : : }
727 : : else
728 : : {
729 : 0 : put_field ("generic_args", "empty");
730 : : }
731 : :
732 : 0 : end ("TypePathSegmentGeneric");
733 : 0 : }
734 : :
735 : : void
736 : 0 : Dump::visit (TypePathSegmentFunction &e)
737 : : {
738 : 0 : begin ("TypePathSegmentFunction");
739 : 0 : do_typepathsegment (e);
740 : :
741 : 0 : begin ("function_path");
742 : 0 : do_typepathfunction (e.get_function_path ());
743 : 0 : end ("function_path");
744 : :
745 : 0 : end ("TypePathSegmentFunction");
746 : 0 : }
747 : :
748 : : void
749 : 0 : Dump::visit (TypePath &e)
750 : : {
751 : 0 : begin ("TypePath");
752 : 0 : put_field ("has_opening_scope_resolution",
753 : 0 : std::to_string (e.has_opening_scope_resolution_op ()));
754 : :
755 : 0 : visit_collection ("segments", e.get_segments ());
756 : :
757 : 0 : end ("TypePath");
758 : 0 : }
759 : :
760 : : void
761 : 0 : Dump::visit (QualifiedPathInExpression &e)
762 : : {
763 : 0 : begin ("QualifiedPathInExpression");
764 : 0 : do_pathpattern (e);
765 : 0 : do_expr (e);
766 : :
767 : 0 : begin_field ("path_type");
768 : :
769 : 0 : begin ("QualifiedPathType");
770 : 0 : do_qualifiedpathtype (e.get_path_type ());
771 : 0 : end ("QualifiedPathType");
772 : :
773 : 0 : end_field ("path_type");
774 : :
775 : 0 : end ("QualifiedPathInExpression");
776 : 0 : }
777 : :
778 : : void
779 : 0 : Dump::visit (QualifiedPathInType &e)
780 : : {
781 : 0 : begin ("QualifiedPathInType");
782 : :
783 : 0 : begin_field ("path_type");
784 : 0 : do_qualifiedpathtype (e.get_path_type ());
785 : 0 : end_field ("path_type");
786 : :
787 : 0 : begin_field ("associated_segment");
788 : 0 : do_typepathsegment (*e.get_associated_segment ());
789 : 0 : end_field ("associated_segment");
790 : :
791 : 0 : visit_collection ("segments", e.get_segments ());
792 : :
793 : 0 : end ("QualifiedPathInType");
794 : 0 : }
795 : :
796 : : void
797 : 0 : Dump::visit (LiteralExpr &e)
798 : : {
799 : 0 : begin ("LiteralExpr");
800 : 0 : do_expr (e);
801 : 0 : put_field ("literal", e.get_literal ().as_string ());
802 : 0 : end ("LiteralExpr");
803 : 0 : }
804 : :
805 : : void
806 : 0 : Dump::visit (BorrowExpr &e)
807 : : {
808 : 0 : begin ("BorrowExpr");
809 : 0 : do_operatorexpr (e);
810 : :
811 : 0 : put_field ("mut", enum_to_str (e.get_mut ()));
812 : :
813 : 0 : end ("BorrowExpr");
814 : 0 : }
815 : :
816 : : void
817 : 0 : Dump::visit (DereferenceExpr &e)
818 : : {
819 : 0 : begin ("DereferenceExpr");
820 : 0 : do_operatorexpr (e);
821 : 0 : end ("DereferenceExpr");
822 : 0 : }
823 : :
824 : : void
825 : 0 : Dump::visit (ErrorPropagationExpr &e)
826 : : {
827 : 0 : begin ("ErrorPropagationExpr");
828 : 0 : do_operatorexpr (e);
829 : 0 : end ("ErrorPropagationExpr");
830 : 0 : }
831 : :
832 : : void
833 : 0 : Dump::visit (NegationExpr &e)
834 : : {
835 : 0 : begin ("NegationExpr");
836 : 0 : do_operatorexpr (e);
837 : 0 : std::string str;
838 : 0 : switch (e.get_expr_type ())
839 : : {
840 : 0 : case NegationOperator::NEGATE:
841 : 0 : str = "[NEGATE]";
842 : 0 : break;
843 : 0 : case NegationOperator::NOT:
844 : 0 : str = "[NOT]";
845 : 0 : break;
846 : 0 : default:
847 : 0 : rust_assert (false);
848 : : }
849 : 0 : put_field ("expr_type", str);
850 : :
851 : 0 : end ("NegationExpr");
852 : 0 : }
853 : :
854 : : void
855 : 0 : Dump::visit (ArithmeticOrLogicalExpr &e)
856 : : {
857 : 0 : begin ("ArithmeticOrLogicalExpr");
858 : 0 : std::string str;
859 : :
860 : : // which operator
861 : 0 : switch (e.get_expr_type ())
862 : : {
863 : 0 : case ArithmeticOrLogicalOperator::ADD:
864 : 0 : str = "[ADD]";
865 : 0 : break;
866 : 0 : case ArithmeticOrLogicalOperator::SUBTRACT:
867 : 0 : str = "SUBTRACT";
868 : 0 : break;
869 : 0 : case ArithmeticOrLogicalOperator::MULTIPLY:
870 : 0 : str = "MULTIPLY";
871 : 0 : break;
872 : 0 : case ArithmeticOrLogicalOperator::DIVIDE:
873 : 0 : str = "DIVIDE";
874 : 0 : break;
875 : 0 : case ArithmeticOrLogicalOperator::MODULUS:
876 : 0 : str = "MODULUS";
877 : 0 : break;
878 : 0 : case ArithmeticOrLogicalOperator::BITWISE_AND:
879 : 0 : str = "BITWISE";
880 : 0 : break;
881 : 0 : case ArithmeticOrLogicalOperator::BITWISE_OR:
882 : 0 : str = "BITWISE";
883 : 0 : break;
884 : 0 : case ArithmeticOrLogicalOperator::BITWISE_XOR:
885 : 0 : str = "BITWISE";
886 : 0 : break;
887 : 0 : case ArithmeticOrLogicalOperator::LEFT_SHIFT:
888 : 0 : str = "<LEFT";
889 : 0 : break;
890 : 0 : case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
891 : 0 : str = ">RIGHT";
892 : 0 : break;
893 : 0 : default:
894 : 0 : rust_unreachable ();
895 : 0 : break;
896 : : }
897 : 0 : put_field ("expr_type", str);
898 : 0 : do_operatorexpr (e);
899 : 0 : visit_field ("right_expr", *e.get_rhs ());
900 : :
901 : 0 : end ("ArithmeticOrLogicalExpr");
902 : 0 : }
903 : :
904 : : void
905 : 0 : Dump::visit (ComparisonExpr &e)
906 : : {
907 : 0 : begin ("ComparisonExpr");
908 : 0 : std::string str;
909 : 0 : switch (e.get_expr_type ())
910 : : {
911 : 0 : case ComparisonOperator::EQUAL:
912 : 0 : str = "EQUAL";
913 : 0 : break;
914 : 0 : case ComparisonOperator::NOT_EQUAL:
915 : 0 : str = "NOT_EQUAL";
916 : 0 : break;
917 : 0 : case ComparisonOperator::GREATER_THAN:
918 : 0 : str = "GREATER_THAN";
919 : 0 : break;
920 : 0 : case ComparisonOperator::LESS_THAN:
921 : 0 : str = "LESS_THAN";
922 : 0 : break;
923 : 0 : case ComparisonOperator::GREATER_OR_EQUAL:
924 : 0 : str = "GREATER_OR_EQUAL";
925 : 0 : break;
926 : 0 : case ComparisonOperator::LESS_OR_EQUAL:
927 : 0 : str = "LESS_OR_EQUAL";
928 : 0 : break;
929 : 0 : default:
930 : 0 : rust_assert (false);
931 : : }
932 : 0 : put_field ("expr_type", str);
933 : 0 : do_operatorexpr (e);
934 : 0 : visit_field ("right_expr", *e.get_rhs ());
935 : 0 : end ("ComparisonExpr");
936 : 0 : }
937 : :
938 : : void
939 : 0 : Dump::visit (LazyBooleanExpr &e)
940 : : {
941 : 0 : begin ("LazyBooleanExpr");
942 : :
943 : 0 : std::string str;
944 : 0 : switch (e.get_expr_type ())
945 : : {
946 : 0 : case LazyBooleanOperator::LOGICAL_OR:
947 : 0 : str = "LOGICAL_OR";
948 : 0 : break;
949 : 0 : case LazyBooleanOperator::LOGICAL_AND:
950 : 0 : str = "LOGICAL_AND";
951 : 0 : break;
952 : 0 : default:
953 : 0 : rust_assert (false);
954 : : }
955 : :
956 : 0 : do_operatorexpr (e);
957 : 0 : visit_field ("right_expr", *e.get_rhs ());
958 : 0 : end ("LazyBooleanExpr");
959 : 0 : }
960 : :
961 : : void
962 : 0 : Dump::visit (TypeCastExpr &e)
963 : : {
964 : 0 : begin ("TypeCastExpr");
965 : 0 : do_operatorexpr (e);
966 : 0 : visit_field ("type_to_convert_to", e.get_type_to_convert_to ());
967 : 0 : end ("TypeCastExpr");
968 : 0 : }
969 : :
970 : : void
971 : 0 : Dump::visit (AssignmentExpr &e)
972 : : {
973 : 0 : begin ("AssignmentExpr");
974 : 0 : do_operatorexpr (e);
975 : 0 : visit_field ("right_expr", *e.get_rhs ());
976 : 0 : end ("AssignmentExpr");
977 : 0 : }
978 : :
979 : : void
980 : 0 : Dump::visit (CompoundAssignmentExpr &e)
981 : : {
982 : 0 : begin ("CompoundAssignmentExpr");
983 : :
984 : 0 : do_operatorexpr (e);
985 : 0 : visit_field ("right_expr", *e.get_rhs ());
986 : :
987 : 0 : std::string str;
988 : :
989 : : // get operator string
990 : 0 : switch (e.get_expr_type ())
991 : : {
992 : 0 : case ArithmeticOrLogicalOperator::ADD:
993 : 0 : str = "ADD";
994 : 0 : break;
995 : 0 : case ArithmeticOrLogicalOperator::SUBTRACT:
996 : 0 : str = "SUBTRACT";
997 : 0 : break;
998 : 0 : case ArithmeticOrLogicalOperator::MULTIPLY:
999 : 0 : str = "MULTIPLY";
1000 : 0 : break;
1001 : 0 : case ArithmeticOrLogicalOperator::DIVIDE:
1002 : 0 : str = "DIVIDE";
1003 : 0 : break;
1004 : 0 : case ArithmeticOrLogicalOperator::MODULUS:
1005 : 0 : str = "MODULUS";
1006 : 0 : break;
1007 : 0 : case ArithmeticOrLogicalOperator::BITWISE_AND:
1008 : 0 : str = "BITWISE_AND";
1009 : 0 : break;
1010 : 0 : case ArithmeticOrLogicalOperator::BITWISE_OR:
1011 : 0 : str = "BITWISE_OR";
1012 : 0 : break;
1013 : 0 : case ArithmeticOrLogicalOperator::BITWISE_XOR:
1014 : 0 : str = "BITWISE_XOR";
1015 : 0 : break;
1016 : 0 : case ArithmeticOrLogicalOperator::LEFT_SHIFT:
1017 : 0 : str = "LEFT_SHIFT";
1018 : 0 : break;
1019 : 0 : case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
1020 : 0 : str = "RIGHT_SHIFT";
1021 : 0 : break;
1022 : 0 : default:
1023 : 0 : gcc_unreachable ();
1024 : 0 : break;
1025 : : }
1026 : 0 : put_field ("expr_type", str);
1027 : 0 : end ("CompoundAssignmentExpr");
1028 : 0 : }
1029 : :
1030 : : void
1031 : 0 : Dump::visit (GroupedExpr &e)
1032 : : {
1033 : 0 : begin ("GroupedExpr");
1034 : 0 : do_expr (e);
1035 : 0 : do_inner_attrs (e);
1036 : :
1037 : 0 : visit_field ("expr_in_parens", e.get_expr_in_parens ());
1038 : :
1039 : 0 : end ("GroupedExpr");
1040 : 0 : }
1041 : :
1042 : : void
1043 : 0 : Dump::visit (ArrayElemsValues &e)
1044 : : {
1045 : 0 : begin ("ArrayElemsValues");
1046 : 0 : do_mappings (e.get_mappings ());
1047 : :
1048 : 0 : visit_collection ("values", e.get_values ());
1049 : 0 : end ("ArrayElemsValues");
1050 : 0 : }
1051 : :
1052 : : void
1053 : 0 : Dump::visit (ArrayElemsCopied &e)
1054 : : {
1055 : 0 : begin ("ArrayElemsCopied");
1056 : 0 : do_mappings (e.get_mappings ());
1057 : :
1058 : 0 : visit_field ("copied_elem", e.get_elem_to_copy ());
1059 : 0 : visit_field ("num_copies", e.get_num_copies_expr ());
1060 : :
1061 : 0 : end ("ArrayElemsCopied");
1062 : 0 : }
1063 : :
1064 : : void
1065 : 0 : Dump::visit (ArrayExpr &e)
1066 : : {
1067 : 0 : begin ("ArrayExpr");
1068 : 0 : do_expr (e);
1069 : 0 : do_inner_attrs (e);
1070 : :
1071 : 0 : visit_field ("internal_elements", e.get_internal_elements ());
1072 : :
1073 : 0 : end ("ArrayExpr");
1074 : 0 : }
1075 : :
1076 : : void
1077 : 0 : Dump::visit (ArrayIndexExpr &e)
1078 : : {
1079 : 0 : begin ("ArrayIndexExpr");
1080 : 0 : do_expr (e);
1081 : :
1082 : 0 : visit_field ("array_expr", e.get_array_expr ());
1083 : 0 : visit_field ("index_expr", e.get_index_expr ());
1084 : 0 : end ("ArrayIndexExpr");
1085 : 0 : }
1086 : :
1087 : : void
1088 : 0 : Dump::visit (TupleExpr &e)
1089 : : {
1090 : 0 : begin ("TupleExpr");
1091 : 0 : do_expr (e);
1092 : 0 : do_inner_attrs (e);
1093 : :
1094 : 0 : visit_collection ("tuple_elems", e.get_tuple_elems ());
1095 : :
1096 : 0 : end ("TupleExpr");
1097 : 0 : }
1098 : :
1099 : : void
1100 : 0 : Dump::visit (TupleIndexExpr &e)
1101 : : {
1102 : 0 : begin ("TupleIndexExpr");
1103 : 0 : do_expr (e);
1104 : 0 : visit_field ("tuple_expr", e.get_tuple_expr ());
1105 : 0 : put_field ("tuple_index", std::to_string (e.get_tuple_index ()));
1106 : 0 : end ("TupleIndexExpr");
1107 : 0 : }
1108 : :
1109 : : void
1110 : 0 : Dump::visit (StructExprStruct &e)
1111 : : {
1112 : 0 : begin ("StructExprStruct");
1113 : 0 : do_structexprstruct (e);
1114 : 0 : end ("StructExprStruct");
1115 : 0 : }
1116 : :
1117 : : void
1118 : 0 : Dump::visit (StructExprFieldIdentifier &e)
1119 : : {
1120 : 0 : begin ("StructExprFieldIdentifier");
1121 : 0 : do_mappings (e.get_mappings ());
1122 : :
1123 : 0 : put_field ("field_name", e.get_field_name ().as_string ());
1124 : 0 : end ("StructExprFieldIdentifier");
1125 : 0 : }
1126 : :
1127 : : void
1128 : 0 : Dump::visit (StructExprFieldIdentifierValue &e)
1129 : : {
1130 : 0 : begin ("StructExprFieldIdentifierValue");
1131 : 0 : do_mappings (e.get_mappings ());
1132 : :
1133 : 0 : visit_field ("value", e.get_value ());
1134 : 0 : end ("StructExprFieldIdentifierValue");
1135 : 0 : }
1136 : :
1137 : : void
1138 : 0 : Dump::visit (StructExprFieldIndexValue &e)
1139 : : {
1140 : 0 : begin ("StructExprFieldIndexValue");
1141 : 0 : do_mappings (e.get_mappings ());
1142 : :
1143 : 0 : put_field ("index", std::to_string (e.get_tuple_index ()));
1144 : 0 : visit_field ("value", e.get_value ());
1145 : 0 : end ("StructExprFieldIndexValue");
1146 : 0 : }
1147 : :
1148 : : void
1149 : 0 : Dump::visit (StructExprStructFields &e)
1150 : : {
1151 : 0 : begin ("StructExprStructFields");
1152 : 0 : do_structexprstruct (e);
1153 : :
1154 : 0 : visit_collection ("fields", e.get_fields ());
1155 : :
1156 : 0 : if (!e.has_struct_base ())
1157 : 0 : put_field ("struct_base", "none");
1158 : : else
1159 : 0 : put_field ("struct_base", e.get_struct_base ()->as_string ());
1160 : :
1161 : 0 : end ("StructExprStructFields");
1162 : 0 : }
1163 : :
1164 : : void
1165 : 0 : Dump::visit (StructExprStructBase &e)
1166 : : {
1167 : 0 : begin ("StructExprStructBase");
1168 : 0 : do_structexprstruct (e);
1169 : :
1170 : 0 : put_field ("struct_base", e.get_struct_base ()->as_string ());
1171 : :
1172 : 0 : end ("StructExprStructBase");
1173 : 0 : }
1174 : :
1175 : : void
1176 : 0 : Dump::visit (CallExpr &e)
1177 : : {
1178 : 0 : begin ("CallExpr");
1179 : 0 : do_expr (e);
1180 : 0 : visit_field ("function", e.get_fnexpr ());
1181 : :
1182 : 0 : visit_collection ("params", e.get_arguments ());
1183 : :
1184 : 0 : end ("CallExpr");
1185 : 0 : }
1186 : :
1187 : : void
1188 : 0 : Dump::visit (MethodCallExpr &e)
1189 : : {
1190 : 0 : begin ("MethodCallExpr");
1191 : 0 : do_expr (e);
1192 : :
1193 : 0 : visit_field ("receiver", e.get_receiver ());
1194 : 0 : put_field ("method_name", e.get_method_name ().as_string ());
1195 : 0 : visit_collection ("params", e.get_arguments ());
1196 : :
1197 : 0 : end ("MethodCallExpr");
1198 : 0 : }
1199 : :
1200 : : void
1201 : 0 : Dump::visit (FieldAccessExpr &e)
1202 : : {
1203 : 0 : begin ("FieldAccessExpr");
1204 : 0 : do_expr (e);
1205 : 0 : visit_field ("receiver", e.get_receiver_expr ());
1206 : 0 : put_field ("field", e.get_field_name ().as_string ());
1207 : 0 : end ("FieldAccessExpr");
1208 : 0 : }
1209 : :
1210 : : void
1211 : 0 : Dump::visit (ClosureExpr &e)
1212 : : {
1213 : 0 : begin ("ClosureExpr");
1214 : 0 : do_expr (e);
1215 : :
1216 : 0 : if (!e.has_params ())
1217 : : {
1218 : 0 : put_field ("params", "none");
1219 : : }
1220 : : else
1221 : : {
1222 : 0 : begin_field ("params");
1223 : 0 : for (auto ¶m : e.get_params ())
1224 : : {
1225 : 0 : begin ("ClosureParam");
1226 : 0 : auto oa = param.get_outer_attrs ();
1227 : 0 : do_outer_attrs (oa);
1228 : 0 : visit_field ("pattern", param.get_pattern ());
1229 : 0 : visit_field ("type", param.get_type ());
1230 : 0 : end ("ClosureParam");
1231 : 0 : }
1232 : 0 : end_field ("params");
1233 : : }
1234 : :
1235 : 0 : visit_field ("return_type", e.get_return_type ());
1236 : :
1237 : 0 : visit_field ("expr", e.get_expr ());
1238 : 0 : end ("ClosureExpr");
1239 : 0 : }
1240 : :
1241 : : void
1242 : 0 : Dump::visit (BlockExpr &e)
1243 : : {
1244 : 0 : begin ("BlockExpr");
1245 : 0 : do_expr (e);
1246 : 0 : do_inner_attrs (e);
1247 : :
1248 : 0 : visit_collection ("statements", e.get_statements ());
1249 : :
1250 : 0 : visit_field ("expr", e.get_final_expr ());
1251 : :
1252 : 0 : end ("BlockExpr");
1253 : 0 : }
1254 : :
1255 : : void
1256 : 0 : Dump::visit (ContinueExpr &e)
1257 : : {
1258 : 0 : begin ("ContinueExpr");
1259 : :
1260 : 0 : if (e.has_label ())
1261 : 0 : put_field ("label", e.get_label ().as_string ());
1262 : : else
1263 : 0 : put_field ("label", "none");
1264 : :
1265 : 0 : end ("ContinueExpr");
1266 : 0 : }
1267 : :
1268 : : void
1269 : 0 : Dump::visit (BreakExpr &e)
1270 : : {
1271 : 0 : begin ("BreakExpr");
1272 : 0 : std::string str ("break ");
1273 : :
1274 : 0 : if (e.has_label ())
1275 : 0 : put_field ("label", e.get_label ().as_string ());
1276 : : else
1277 : 0 : put_field ("label", "none");
1278 : :
1279 : 0 : visit_field ("break_expr ", e.get_expr ());
1280 : :
1281 : 0 : end ("BreakExpr");
1282 : 0 : }
1283 : :
1284 : : void
1285 : 0 : Dump::visit (RangeFromToExpr &e)
1286 : : {
1287 : 0 : begin ("RangeFromToExpr");
1288 : :
1289 : 0 : visit_field ("from", e.get_from_expr ());
1290 : 0 : visit_field ("to", e.get_to_expr ());
1291 : :
1292 : 0 : end ("RangeFromToExpr");
1293 : 0 : }
1294 : :
1295 : : void
1296 : 0 : Dump::visit (RangeFromExpr &e)
1297 : : {
1298 : 0 : begin ("RangeFromExpr");
1299 : :
1300 : 0 : visit_field ("from", e.get_from_expr ());
1301 : :
1302 : 0 : end ("RangeFromExpr");
1303 : 0 : }
1304 : :
1305 : : void
1306 : 0 : Dump::visit (RangeToExpr &e)
1307 : : {
1308 : 0 : begin ("RangeToExpr");
1309 : :
1310 : 0 : visit_field ("to", e.get_to_expr ());
1311 : :
1312 : 0 : end ("RangeToExpr");
1313 : 0 : }
1314 : :
1315 : : void
1316 : 0 : Dump::visit (RangeFullExpr &e)
1317 : : {
1318 : 0 : begin ("RangeFullExpr");
1319 : 0 : end ("RangeFullExpr");
1320 : 0 : }
1321 : :
1322 : : void
1323 : 0 : Dump::visit (RangeFromToInclExpr &e)
1324 : : {
1325 : 0 : begin ("RangeFromToInclExpr");
1326 : :
1327 : 0 : visit_field ("from", e.get_from_expr ());
1328 : 0 : visit_field ("to", e.get_to_expr ());
1329 : :
1330 : 0 : end ("RangeFromToInclExpr");
1331 : 0 : }
1332 : :
1333 : : void
1334 : 0 : Dump::visit (RangeToInclExpr &e)
1335 : : {
1336 : 0 : begin ("RangeToInclExpr");
1337 : :
1338 : 0 : visit_field ("to", e.get_to_expr ());
1339 : :
1340 : 0 : end ("RangeToInclExpr");
1341 : 0 : }
1342 : :
1343 : : void
1344 : 0 : Dump::visit (ReturnExpr &e)
1345 : : {
1346 : 0 : begin ("ReturnExpr");
1347 : 0 : do_mappings (e.get_mappings ());
1348 : :
1349 : 0 : visit_field ("return_expr", e.get_expr ());
1350 : :
1351 : 0 : end ("ReturnExpr");
1352 : 0 : }
1353 : :
1354 : : void
1355 : 0 : Dump::visit (UnsafeBlockExpr &e)
1356 : : {
1357 : 0 : begin ("UnsafeBlockExpr");
1358 : 0 : auto oa = e.get_outer_attrs ();
1359 : 0 : do_outer_attrs (oa);
1360 : :
1361 : 0 : visit_field ("block_expr", e.get_block_expr ());
1362 : :
1363 : 0 : end ("UnsafeBlockExpr");
1364 : 0 : }
1365 : :
1366 : : void
1367 : 0 : Dump::visit (LoopExpr &e)
1368 : : {
1369 : 0 : begin ("LoopExpr");
1370 : 0 : do_baseloopexpr (e);
1371 : 0 : end ("LoopExpr");
1372 : 0 : }
1373 : :
1374 : : void
1375 : 0 : Dump::visit (WhileLoopExpr &e)
1376 : : {
1377 : 0 : begin ("WhileLoopExpr");
1378 : 0 : do_baseloopexpr (e);
1379 : :
1380 : 0 : visit_field ("condition", e.get_predicate_expr ());
1381 : :
1382 : 0 : end ("WhileLoopExpr");
1383 : 0 : }
1384 : :
1385 : : void
1386 : 0 : Dump::visit (WhileLetLoopExpr &e)
1387 : : {
1388 : 0 : begin ("WhileLetLoopExpr");
1389 : 0 : do_baseloopexpr (e);
1390 : :
1391 : 0 : visit_collection ("match_arm_patterns", e.get_patterns ());
1392 : :
1393 : 0 : visit_field ("condition", e.get_cond ());
1394 : :
1395 : 0 : end ("WhileLetLoopExpr");
1396 : 0 : }
1397 : :
1398 : : void
1399 : 0 : Dump::visit (IfExpr &e)
1400 : : {
1401 : 0 : begin ("IfExpr");
1402 : 0 : do_ifexpr (e);
1403 : 0 : end ("IfExpr");
1404 : 0 : }
1405 : :
1406 : : void
1407 : 0 : Dump::visit (IfExprConseqElse &e)
1408 : : {
1409 : 0 : begin ("IfExprConseqElse");
1410 : 0 : do_ifexpr (e);
1411 : 0 : visit_field ("else_block", e.get_else_block ());
1412 : :
1413 : 0 : end ("IfExprConseqElse");
1414 : 0 : }
1415 : :
1416 : : void
1417 : 0 : Dump::visit (IfLetExpr &e)
1418 : : {
1419 : 0 : begin ("IfLetExpr");
1420 : 0 : do_ifletexpr (e);
1421 : 0 : end ("IfLetExpr");
1422 : 0 : }
1423 : :
1424 : : void
1425 : 0 : Dump::visit (IfLetExprConseqElse &e)
1426 : : {
1427 : 0 : begin ("IfLetExprConseqElse");
1428 : 0 : do_ifletexpr (e);
1429 : 0 : visit_field ("else_block", e.get_else_block ());
1430 : 0 : end ("IfLetExprConseqElse");
1431 : 0 : }
1432 : :
1433 : : void
1434 : 0 : Dump::visit (MatchExpr &e)
1435 : : {
1436 : 0 : begin ("MatchExpr");
1437 : 0 : do_inner_attrs (e);
1438 : 0 : do_expr (e);
1439 : 0 : visit_field ("branch_value", e.get_scrutinee_expr ());
1440 : :
1441 : 0 : std::string str;
1442 : 0 : if (e.get_match_cases ().empty ())
1443 : 0 : str = "none";
1444 : : else
1445 : 0 : for (const auto &arm : e.get_match_cases ())
1446 : 0 : str += "\n " + arm.as_string ();
1447 : 0 : put_field ("match_arms", str);
1448 : :
1449 : 0 : end ("MatchExpr");
1450 : 0 : }
1451 : :
1452 : : void
1453 : 0 : Dump::visit (AwaitExpr &e)
1454 : : {
1455 : 0 : begin ("AwaitExpr");
1456 : 0 : do_expr (e);
1457 : 0 : visit_field ("awaited_expr", e.get_awaited_expr ());
1458 : 0 : end ("AwaitExpr");
1459 : 0 : }
1460 : :
1461 : : void
1462 : 0 : Dump::visit (AsyncBlockExpr &e)
1463 : : {
1464 : 0 : begin ("AsyncBlockExpr");
1465 : 0 : do_expr (e);
1466 : :
1467 : 0 : put_field ("has move", std::to_string (e.get_has_move ()));
1468 : 0 : visit_field ("block_expr", e.get_block_expr ());
1469 : :
1470 : 0 : end ("AsyncBlockExpr");
1471 : 0 : }
1472 : :
1473 : : void
1474 : 0 : Dump::visit (TypeParam &e)
1475 : : {
1476 : 0 : begin ("TypeParam");
1477 : 0 : put_field ("outer_attr", e.get_outer_attribute ().as_string ());
1478 : :
1479 : 0 : put_field ("type_representation", e.get_type_representation ().as_string ());
1480 : :
1481 : 0 : visit_collection ("type_param_bounds", e.get_type_param_bounds ());
1482 : :
1483 : 0 : visit_field ("type", e.get_type ());
1484 : :
1485 : 0 : end ("TypeParam");
1486 : 0 : }
1487 : :
1488 : : void
1489 : 0 : Dump::visit (ConstGenericParam &e)
1490 : : {
1491 : 0 : begin ("ConstGenericParam");
1492 : 0 : do_mappings (e.get_mappings ());
1493 : 0 : put_field ("name", e.get_name ());
1494 : 0 : visit_field ("type", e.get_type ());
1495 : 0 : visit_field ("default_expression", e.get_default_expression ());
1496 : 0 : end ("ConstGenericParam");
1497 : 0 : }
1498 : :
1499 : : void
1500 : 0 : Dump::visit (LifetimeWhereClauseItem &e)
1501 : : {
1502 : 0 : begin ("LifetimeWhereClauseItem");
1503 : 0 : do_mappings (e.get_mappings ());
1504 : :
1505 : 0 : visit_field ("lifetime", e.get_lifetime ());
1506 : 0 : visit_collection ("lifetime_bounds", e.get_lifetime_bounds ());
1507 : :
1508 : 0 : end ("LifetimeWhereClauseItem");
1509 : 0 : }
1510 : :
1511 : : void
1512 : 0 : Dump::visit (TypeBoundWhereClauseItem &e)
1513 : : {
1514 : 0 : begin ("TypeBoundWhereClauseItem");
1515 : 0 : do_mappings (e.get_mappings ());
1516 : :
1517 : 0 : visit_collection ("for_lifetime", e.get_for_lifetimes ());
1518 : :
1519 : 0 : visit_field ("bound_type", e.get_bound_type ());
1520 : 0 : visit_collection ("type_param_bound", e.get_type_param_bounds ());
1521 : 0 : end ("TypeBoundWhereClauseItem");
1522 : 0 : }
1523 : :
1524 : : void
1525 : 0 : Dump::visit (Module &e)
1526 : : {
1527 : 0 : begin ("Module");
1528 : 0 : do_inner_attrs (e);
1529 : 0 : put_field ("module_name", e.get_module_name ().as_string ());
1530 : 0 : visit_collection ("items", e.get_items ());
1531 : :
1532 : 0 : end ("Module");
1533 : 0 : }
1534 : :
1535 : : void
1536 : 0 : Dump::visit (ExternCrate &e)
1537 : : {
1538 : 0 : begin ("ExternCrate");
1539 : 0 : do_vis_item (e);
1540 : 0 : put_field ("referenced_crate", e.get_referenced_crate ());
1541 : 0 : put_field ("as_clause_name", e.get_as_clause_name ());
1542 : :
1543 : 0 : end ("ExternCrate");
1544 : 0 : }
1545 : :
1546 : : void
1547 : 0 : Dump::visit (UseTreeGlob &e)
1548 : : {
1549 : 0 : begin ("UseTreeGlob");
1550 : :
1551 : 0 : std::string glob, path = "not applicable";
1552 : 0 : switch (e.get_glob_type ())
1553 : : {
1554 : 0 : case UseTreeGlob::PathType::NO_PATH:
1555 : 0 : glob = "*";
1556 : 0 : break;
1557 : 0 : case UseTreeGlob::PathType::GLOBAL:
1558 : 0 : glob = "::*";
1559 : 0 : break;
1560 : 0 : case UseTreeGlob::PathType::PATH_PREFIXED: {
1561 : 0 : path = e.get_path ().as_string ();
1562 : 0 : glob = "::*";
1563 : 0 : break;
1564 : : }
1565 : 0 : default:
1566 : 0 : gcc_unreachable ();
1567 : : }
1568 : 0 : put_field ("glob", glob);
1569 : 0 : put_field ("path", path);
1570 : :
1571 : 0 : end ("UseTreeGlob");
1572 : 0 : }
1573 : :
1574 : : void
1575 : 0 : Dump::visit (UseTreeList &e)
1576 : : {
1577 : 0 : begin ("UseTreeList");
1578 : :
1579 : 0 : std::string path_type, path = "not applicable";
1580 : 0 : switch (e.get_path_type ())
1581 : : {
1582 : 0 : case UseTreeList::PathType::NO_PATH:
1583 : 0 : path_type = "*";
1584 : 0 : break;
1585 : 0 : case UseTreeList::PathType::GLOBAL:
1586 : 0 : path_type = "::*";
1587 : 0 : break;
1588 : 0 : case UseTreeList::PathType::PATH_PREFIXED: {
1589 : 0 : path = e.get_path ().as_string ();
1590 : 0 : path_type = "::*";
1591 : 0 : break;
1592 : : }
1593 : 0 : default:
1594 : 0 : gcc_unreachable ();
1595 : : }
1596 : 0 : put_field ("path_type", path_type);
1597 : 0 : put_field ("path", path);
1598 : :
1599 : 0 : visit_collection ("trees", e.get_trees ());
1600 : :
1601 : 0 : end ("UseTreeList");
1602 : 0 : }
1603 : :
1604 : : void
1605 : 0 : Dump::visit (UseTreeRebind &e)
1606 : : {
1607 : 0 : begin ("UseTreeRebind");
1608 : 0 : put_field ("path", e.get_path ().as_string ());
1609 : 0 : put_field ("identifier", e.get_identifier ().as_string ());
1610 : 0 : put_field ("bind_type", enum_to_str (e.get_bind_type ()));
1611 : 0 : end ("UseTreeRebind");
1612 : 0 : }
1613 : :
1614 : : void
1615 : 0 : Dump::visit (UseDeclaration &e)
1616 : : {
1617 : 0 : begin ("UseDeclaration");
1618 : 0 : do_vis_item (e);
1619 : :
1620 : 0 : visit_field ("use_tree", e.get_use_tree ());
1621 : :
1622 : 0 : end ("UseDeclaration");
1623 : 0 : }
1624 : :
1625 : : void
1626 : 0 : Dump::visit (Function &e)
1627 : : {
1628 : 0 : begin ("Function");
1629 : 0 : do_vis_item (e);
1630 : :
1631 : 0 : put_field ("function_qualifiers", e.get_qualifiers ().as_string ());
1632 : :
1633 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1634 : :
1635 : 0 : put_field ("function_name", e.get_function_name ().as_string ());
1636 : :
1637 : 0 : if (e.has_function_params ())
1638 : : {
1639 : 0 : begin_field ("function_params");
1640 : 0 : for (auto &item : e.get_function_params ())
1641 : 0 : do_functionparam (item);
1642 : 0 : end_field ("function_params");
1643 : : }
1644 : : else
1645 : : {
1646 : 0 : put_field ("function_params", "empty");
1647 : : }
1648 : :
1649 : 0 : visit_field ("return_type", e.get_return_type ());
1650 : :
1651 : 0 : if (!e.has_where_clause ())
1652 : 0 : put_field ("where_clause", "none");
1653 : : else
1654 : 0 : put_field ("where clause", e.get_where_clause ().as_string ());
1655 : :
1656 : 0 : visit_field ("function_body", e.get_definition ());
1657 : 0 : put_field ("self", e.get_self_param ().as_string ());
1658 : :
1659 : 0 : end ("Function");
1660 : 0 : }
1661 : :
1662 : : void
1663 : 0 : Dump::visit (TypeAlias &e)
1664 : : {
1665 : 0 : begin ("TypeAlias");
1666 : :
1667 : 0 : do_vis_item (e);
1668 : :
1669 : 0 : put_field ("new_type_name", e.get_new_type_name ().as_string ());
1670 : :
1671 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1672 : :
1673 : 0 : if (!e.has_where_clause ())
1674 : 0 : put_field ("where_clause", "none");
1675 : : else
1676 : 0 : put_field ("where clause", e.get_where_clause ().as_string ());
1677 : :
1678 : 0 : put_field ("type", e.get_type_aliased ()->as_string ());
1679 : :
1680 : 0 : end ("TypeAlias");
1681 : 0 : }
1682 : :
1683 : : void
1684 : 0 : Dump::visit (StructStruct &e)
1685 : : {
1686 : 0 : begin ("StructStruct");
1687 : 0 : do_struct (e);
1688 : :
1689 : 0 : put_field ("is_unit", std::to_string (e.is_unit_struct ()));
1690 : :
1691 : 0 : if (e.get_fields ().empty ())
1692 : 0 : put_field ("fields", "empty");
1693 : : else
1694 : : {
1695 : 0 : begin_field ("fields");
1696 : 0 : for (auto &field : e.get_fields ())
1697 : : {
1698 : 0 : begin ("StructField");
1699 : 0 : do_structfield (field);
1700 : 0 : end ("StructField");
1701 : : }
1702 : 0 : end_field ("fields");
1703 : : }
1704 : :
1705 : 0 : end ("StructStruct");
1706 : 0 : }
1707 : :
1708 : : void
1709 : 0 : Dump::visit (TupleStruct &e)
1710 : : {
1711 : 0 : begin ("TupleStruct");
1712 : 0 : do_struct (e);
1713 : :
1714 : 0 : if (e.get_fields ().empty ())
1715 : 0 : put_field ("fields", "empty");
1716 : : else
1717 : : {
1718 : 0 : begin_field ("fields");
1719 : 0 : for (auto &field : e.get_fields ())
1720 : : {
1721 : 0 : begin ("TupleField");
1722 : 0 : do_tuplefield (field);
1723 : 0 : end ("TupleField");
1724 : : }
1725 : 0 : end_field ("fields");
1726 : : }
1727 : :
1728 : 0 : end ("TupleStruct");
1729 : 0 : }
1730 : :
1731 : : void
1732 : 0 : Dump::visit (EnumItem &e)
1733 : : {
1734 : 0 : begin ("EnumItem");
1735 : 0 : do_enumitem (e);
1736 : 0 : end ("EnumItem");
1737 : 0 : }
1738 : :
1739 : : void
1740 : 0 : Dump::visit (EnumItemTuple &e)
1741 : : {
1742 : 0 : begin ("EnumItemTuple");
1743 : 0 : do_enumitem (e);
1744 : :
1745 : 0 : if (e.has_tuple_fields ())
1746 : : {
1747 : 0 : begin_field ("tuple_fields");
1748 : 0 : for (auto field : e.get_tuple_fields ())
1749 : 0 : do_tuplefield (field);
1750 : 0 : end_field ("tuple_fields");
1751 : : }
1752 : : else
1753 : 0 : put_field ("tuple_fields", "empty");
1754 : :
1755 : 0 : end ("EnumItemTuple");
1756 : 0 : }
1757 : :
1758 : : void
1759 : 0 : Dump::visit (EnumItemStruct &e)
1760 : : {
1761 : 0 : begin ("EnumItemStruct");
1762 : 0 : do_enumitem (e);
1763 : :
1764 : 0 : if (e.has_struct_fields ())
1765 : : {
1766 : 0 : begin_field ("struct_fields");
1767 : 0 : for (auto field : e.get_struct_fields ())
1768 : 0 : do_structfield (field);
1769 : 0 : end_field ("struct_fields");
1770 : : }
1771 : : else
1772 : : {
1773 : 0 : put_field ("struct_fields", "empty");
1774 : : }
1775 : 0 : end ("EnumItemStruct");
1776 : 0 : }
1777 : :
1778 : : void
1779 : 0 : Dump::visit (EnumItemDiscriminant &e)
1780 : : {
1781 : 0 : begin ("EnumItemDiscriminant");
1782 : :
1783 : 0 : do_enumitem (e);
1784 : :
1785 : 0 : visit_field ("discriminant", e.get_discriminant_expression ());
1786 : :
1787 : 0 : end ("EnumItemDiscriminant");
1788 : 0 : }
1789 : :
1790 : : void
1791 : 0 : Dump::visit (Enum &e)
1792 : : {
1793 : 0 : begin ("Enum");
1794 : 0 : do_vis_item (e);
1795 : :
1796 : 0 : put_field ("enum_name", e.get_identifier ().as_string ());
1797 : :
1798 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1799 : :
1800 : 0 : std::string str = "none";
1801 : 0 : if (e.has_where_clause ())
1802 : 0 : str = e.get_where_clause ().as_string ();
1803 : 0 : put_field ("where clause", str);
1804 : :
1805 : 0 : visit_collection ("items", e.get_variants ());
1806 : :
1807 : 0 : end ("Enum");
1808 : 0 : }
1809 : :
1810 : : void
1811 : 0 : Dump::visit (Union &e)
1812 : : {
1813 : 0 : begin ("Union");
1814 : 0 : do_vis_item (e);
1815 : :
1816 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1817 : :
1818 : 0 : std::string str;
1819 : 0 : if (e.has_where_clause ())
1820 : 0 : str = e.get_where_clause ().as_string ();
1821 : : else
1822 : 0 : str = "none";
1823 : 0 : put_field ("where clause", str);
1824 : :
1825 : 0 : if (e.get_variants ().empty ())
1826 : : {
1827 : 0 : put_field ("variants", "empty");
1828 : : }
1829 : : else
1830 : : {
1831 : 0 : begin_field ("variants");
1832 : 0 : for (auto &elt : e.get_variants ())
1833 : : {
1834 : 0 : begin ("StructField");
1835 : 0 : auto oa = e.get_outer_attrs ();
1836 : 0 : do_outer_attrs (oa);
1837 : :
1838 : 0 : std::string str = "none";
1839 : 0 : if (elt.has_visibility ())
1840 : 0 : str = elt.get_visibility ().as_string ();
1841 : 0 : put_field ("visibility", str);
1842 : 0 : put_field ("field_name", elt.get_field_name ().as_string ());
1843 : 0 : visit_field ("field_type", elt.get_field_type ());
1844 : 0 : end ("StructField");
1845 : 0 : }
1846 : 0 : end_field ("variants");
1847 : : }
1848 : 0 : end ("Union");
1849 : 0 : }
1850 : :
1851 : : void
1852 : 0 : Dump::visit (ConstantItem &e)
1853 : : {
1854 : 0 : begin ("ConstantItem");
1855 : 0 : do_vis_item (e);
1856 : 0 : put_field ("identifier", e.get_identifier ().as_string ());
1857 : 0 : visit_field ("type", e.get_type ());
1858 : 0 : visit_field ("const_expr", e.get_expr ());
1859 : 0 : end ("ConstantItem");
1860 : 0 : }
1861 : :
1862 : : void
1863 : 0 : Dump::visit (StaticItem &e)
1864 : : {
1865 : 0 : begin ("StaticItem");
1866 : 0 : do_vis_item (e);
1867 : 0 : put_field ("mut", std::to_string (e.is_mut ()));
1868 : 0 : put_field ("name", e.get_identifier ().as_string ());
1869 : 0 : visit_field ("type", e.get_type ());
1870 : 0 : visit_field ("expr", e.get_expr ());
1871 : 0 : end ("StaticItem");
1872 : 0 : }
1873 : :
1874 : : void
1875 : 0 : Dump::visit (TraitItemFunc &e)
1876 : : {
1877 : 0 : begin ("TraitItemFunc");
1878 : 0 : do_traititem (e);
1879 : :
1880 : 0 : do_traitfunctiondecl (e.get_decl ());
1881 : :
1882 : 0 : visit_field ("block_expr", e.get_block_expr ());
1883 : :
1884 : 0 : end ("TraitItemFunc");
1885 : 0 : }
1886 : :
1887 : : void
1888 : 0 : Dump::visit (TraitItemConst &e)
1889 : : {
1890 : 0 : begin ("TraitItemConst");
1891 : 0 : do_traititem (e);
1892 : :
1893 : 0 : put_field ("name", e.get_name ().as_string ());
1894 : 0 : visit_field ("type", e.get_type ());
1895 : 0 : visit_field ("expr", e.get_expr ());
1896 : 0 : end ("TraitItemConst");
1897 : 0 : }
1898 : :
1899 : : void
1900 : 0 : Dump::visit (TraitItemType &e)
1901 : : {
1902 : 0 : begin ("TraitItemType");
1903 : 0 : do_traititem (e);
1904 : :
1905 : 0 : put_field ("name", e.get_name ().as_string ());
1906 : 0 : visit_collection ("type_param_bounds", e.get_type_param_bounds ());
1907 : 0 : end ("TraitItemType");
1908 : 0 : }
1909 : :
1910 : : void
1911 : 0 : Dump::visit (Trait &e)
1912 : : {
1913 : 0 : begin ("Trait");
1914 : 0 : do_vis_item (e);
1915 : 0 : put_field ("unsafety", std::to_string (e.is_unsafe ()));
1916 : 0 : put_field ("name", e.get_name ().as_string ());
1917 : :
1918 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1919 : :
1920 : 0 : visit_collection ("type_param_bounds", e.get_type_param_bounds ());
1921 : :
1922 : 0 : std::string str;
1923 : 0 : if (e.has_where_clause ())
1924 : 0 : str = e.get_where_clause ().as_string ();
1925 : : else
1926 : 0 : str = "none";
1927 : 0 : put_field ("where clause", str);
1928 : :
1929 : 0 : visit_collection ("trait_items", e.get_trait_items ());
1930 : :
1931 : 0 : end ("Trait");
1932 : 0 : }
1933 : :
1934 : : void
1935 : 0 : Dump::visit (ImplBlock &e)
1936 : : {
1937 : 0 : begin ("ImplBlock");
1938 : 0 : do_vis_item (e);
1939 : :
1940 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1941 : :
1942 : 0 : visit_field ("impl_type", e.get_type ());
1943 : :
1944 : 0 : std::string str;
1945 : 0 : if (e.has_where_clause ())
1946 : 0 : str = e.get_where_clause ().as_string ();
1947 : : else
1948 : 0 : str = "none";
1949 : 0 : put_field ("where clause", str);
1950 : :
1951 : 0 : do_inner_attrs (e);
1952 : :
1953 : 0 : visit_collection ("impl_items", e.get_impl_items ());
1954 : :
1955 : 0 : end ("ImplBlock");
1956 : 0 : }
1957 : :
1958 : : void
1959 : 0 : Dump::visit (ExternalStaticItem &e)
1960 : : {
1961 : 0 : begin ("ExternalStaticItem");
1962 : :
1963 : : // FIXME do_vis_item... but not a VisItem... But could be?
1964 : 0 : auto oa = e.get_outer_attrs ();
1965 : 0 : do_outer_attrs (oa);
1966 : :
1967 : 0 : std::string str = "none";
1968 : 0 : if (e.has_visibility ())
1969 : 0 : str = e.get_visibility ().as_string ();
1970 : 0 : put_field ("visibility", str);
1971 : : //
1972 : :
1973 : 0 : put_field ("mut", std::to_string (e.is_mut ()));
1974 : 0 : put_field ("name", e.get_item_name ().as_string ());
1975 : 0 : visit_field ("type", e.get_item_type ());
1976 : :
1977 : 0 : end ("ExternalStaticItem");
1978 : 0 : }
1979 : :
1980 : : void
1981 : 0 : Dump::visit (ExternalFunctionItem &e)
1982 : : {
1983 : 0 : begin ("ExternalFunctionItem");
1984 : 0 : do_externalitem (e);
1985 : :
1986 : 0 : visit_collection ("generic_params", e.get_generic_params ());
1987 : :
1988 : 0 : std::string str = "none";
1989 : 0 : if (!e.get_function_params ().empty ())
1990 : 0 : for (auto ¶m : e.get_function_params ())
1991 : 0 : do_namefunctionparam (param);
1992 : : else
1993 : 0 : put_field ("function_params", "none");
1994 : :
1995 : 0 : put_field ("has_variadics", std::to_string (e.is_variadic ()));
1996 : :
1997 : 0 : visit_field ("return_type", e.get_return_type ());
1998 : :
1999 : 0 : end ("ExternalFunctionItem");
2000 : 0 : }
2001 : :
2002 : : void
2003 : 0 : Dump::visit (ExternalTypeItem &e)
2004 : : {
2005 : 0 : begin ("ExternalTypeItem");
2006 : :
2007 : 0 : do_externalitem (e);
2008 : :
2009 : 0 : end ("ExternalTypeItem");
2010 : 0 : }
2011 : :
2012 : : void
2013 : 0 : Dump::visit (ExternBlock &e)
2014 : : {
2015 : 0 : begin ("ExternBlock");
2016 : 0 : do_vis_item (e);
2017 : 0 : do_inner_attrs (e);
2018 : :
2019 : 0 : put_field ("abi", get_string_from_abi (e.get_abi ()));
2020 : :
2021 : 0 : visit_collection ("extern_items", e.get_extern_items ());
2022 : :
2023 : 0 : end ("ExternBlock");
2024 : 0 : }
2025 : :
2026 : : void
2027 : 0 : Dump::visit (LiteralPattern &e)
2028 : : {
2029 : 0 : begin ("LiteralPattern");
2030 : 0 : put_field ("lit", e.get_literal ().as_string ());
2031 : 0 : do_mappings (e.get_mappings ());
2032 : 0 : end ("LiteralPattern");
2033 : 0 : }
2034 : :
2035 : : void
2036 : 0 : Dump::visit (IdentifierPattern &e)
2037 : : {
2038 : 0 : begin ("IdentifierPattern");
2039 : 0 : put_field ("variable_ident", e.get_identifier ().as_string ());
2040 : 0 : put_field ("is_ref", std::to_string (e.get_is_ref ()));
2041 : 0 : put_field ("mut", std::to_string (e.is_mut ()));
2042 : :
2043 : 0 : if (e.has_pattern_to_bind ())
2044 : 0 : put_field ("to_bind", e.get_to_bind ()->as_string ());
2045 : : else
2046 : 0 : put_field ("to_bind", "none");
2047 : :
2048 : 0 : end ("IdentifierPattern");
2049 : 0 : }
2050 : : void
2051 : 0 : Dump::visit (WildcardPattern &e)
2052 : : {
2053 : 0 : begin ("WildcardPattern");
2054 : 0 : do_mappings (e.get_mappings ());
2055 : 0 : end ("WildcardPattern");
2056 : 0 : }
2057 : :
2058 : : void
2059 : 0 : Dump::visit (RangePatternBoundLiteral &e)
2060 : : {
2061 : 0 : begin ("RangePatternBoundLiteral");
2062 : 0 : put_field ("literal", e.get_literal ().as_string ());
2063 : 0 : put_field ("has_minus", std::to_string (e.get_has_minus ()));
2064 : 0 : end ("RangePatternBoundLiteral");
2065 : 0 : }
2066 : :
2067 : : void
2068 : 0 : Dump::visit (RangePatternBoundPath &e)
2069 : : {
2070 : 0 : begin ("RangePatternBoundPath");
2071 : 0 : put_field ("path", e.get_path ().as_string ());
2072 : 0 : end ("RangePatternBoundPath");
2073 : 0 : }
2074 : :
2075 : : void
2076 : 0 : Dump::visit (RangePatternBoundQualPath &e)
2077 : : {
2078 : 0 : begin ("RangePatternBoundQualPath");
2079 : 0 : visit_field ("path", e.get_qualified_path ());
2080 : 0 : end ("RangePatternBoundQualPath");
2081 : 0 : }
2082 : :
2083 : : void
2084 : 0 : Dump::visit (RangePattern &e)
2085 : : {
2086 : 0 : begin ("RangePattern");
2087 : 0 : do_mappings (e.get_mappings ());
2088 : 0 : put_field ("lower", e.get_lower_bound ()->as_string ());
2089 : 0 : put_field ("upper", e.get_upper_bound ()->as_string ());
2090 : 0 : put_field ("has_ellipsis_syntax",
2091 : 0 : std::to_string (e.get_has_ellipsis_syntax ()));
2092 : 0 : end ("RangePattern");
2093 : 0 : }
2094 : :
2095 : : void
2096 : 0 : Dump::visit (ReferencePattern &e)
2097 : : {
2098 : 0 : begin ("ReferencePattern");
2099 : 0 : do_mappings (e.get_mappings ());
2100 : 0 : put_field ("mut", std::to_string (e.is_mut ()));
2101 : 0 : put_field ("pattern", e.get_referenced_pattern ()->as_string ());
2102 : 0 : end ("ReferencePattern");
2103 : 0 : }
2104 : :
2105 : : void
2106 : 0 : Dump::visit (StructPatternFieldTuplePat &e)
2107 : : {
2108 : 0 : begin ("StructPatternFieldTuplePat");
2109 : 0 : do_mappings (e.get_mappings ());
2110 : 0 : auto oa = e.get_outer_attrs ();
2111 : 0 : do_outer_attrs (oa);
2112 : 0 : put_field ("index", std::to_string (e.get_index ()));
2113 : 0 : put_field ("tuple_pattern", e.get_tuple_pattern ()->as_string ());
2114 : 0 : end ("StructPatternFieldTuplePat");
2115 : 0 : }
2116 : :
2117 : : void
2118 : 0 : Dump::visit (StructPatternFieldIdentPat &e)
2119 : : {
2120 : 0 : begin ("StructPatternFieldIdentPat");
2121 : 0 : auto oa = e.get_outer_attrs ();
2122 : 0 : do_outer_attrs (oa);
2123 : 0 : put_field ("ident", e.get_identifier ().as_string ());
2124 : 0 : put_field ("ident_pattern", e.get_pattern ()->as_string ());
2125 : 0 : end ("StructPatternFieldIdentPat");
2126 : 0 : }
2127 : :
2128 : : void
2129 : 0 : Dump::visit (StructPatternFieldIdent &e)
2130 : : {
2131 : 0 : begin ("StructPatternFieldIdent");
2132 : 0 : auto oa = e.get_outer_attrs ();
2133 : 0 : do_outer_attrs (oa);
2134 : :
2135 : 0 : put_field ("has_ref", std::to_string (e.get_has_ref ()));
2136 : 0 : put_field ("mut", std::to_string (e.is_mut ()));
2137 : 0 : put_field ("ident", e.get_identifier ().as_string ());
2138 : 0 : end ("StructPatternFieldIdent");
2139 : 0 : }
2140 : :
2141 : : void
2142 : 0 : Dump::visit (StructPattern &e)
2143 : : {
2144 : 0 : begin ("StructPattern");
2145 : :
2146 : 0 : visit_field ("path", e.get_path ());
2147 : 0 : put_field ("elems", e.get_struct_pattern_elems ().as_string ());
2148 : :
2149 : 0 : end ("StructPattern");
2150 : 0 : }
2151 : :
2152 : : void
2153 : 0 : Dump::visit (TupleStructItemsNoRange &e)
2154 : : {
2155 : 0 : begin ("TupleStructItemsNoRange");
2156 : 0 : visit_collection ("patterns", e.get_patterns ());
2157 : 0 : end ("TupleStructItemsNoRange");
2158 : 0 : }
2159 : :
2160 : : void
2161 : 0 : Dump::visit (TupleStructItemsRange &e)
2162 : : {
2163 : 0 : begin ("TupleStructItemsRange");
2164 : 0 : visit_collection ("lower_patterns", e.get_lower_patterns ());
2165 : 0 : visit_collection ("upper_patterns", e.get_upper_patterns ());
2166 : 0 : end ("TupleStructItemsRange");
2167 : 0 : }
2168 : :
2169 : : void
2170 : 0 : Dump::visit (TupleStructPattern &e)
2171 : : {
2172 : 0 : begin ("TupleStructPattern");
2173 : 0 : do_mappings (e.get_mappings ());
2174 : :
2175 : 0 : put_field ("path", e.get_path ().as_string ());
2176 : :
2177 : 0 : visit_field ("items", e.get_items ());
2178 : :
2179 : 0 : end ("TupleStructPattern");
2180 : 0 : }
2181 : :
2182 : : void
2183 : 0 : Dump::visit (TuplePatternItemsMultiple &e)
2184 : : {
2185 : 0 : begin ("TuplePatternItemsMultiple");
2186 : 0 : visit_collection ("patterns", e.get_patterns ());
2187 : 0 : end ("TuplePatternItemsMultiple");
2188 : 0 : }
2189 : :
2190 : : void
2191 : 0 : Dump::visit (TuplePatternItemsRanged &e)
2192 : : {
2193 : 0 : begin ("TuplePatternItemsRanged");
2194 : 0 : visit_collection ("lower_patterns", e.get_lower_patterns ());
2195 : 0 : visit_collection ("upper_patterns", e.get_upper_patterns ());
2196 : 0 : end ("TuplePatternItemsRanged");
2197 : 0 : }
2198 : :
2199 : : void
2200 : 0 : Dump::visit (TuplePattern &e)
2201 : : {
2202 : 0 : begin ("TuplePattern");
2203 : 0 : do_mappings (e.get_mappings ());
2204 : 0 : visit_field ("items", e.get_items ());
2205 : 0 : end ("TuplePattern");
2206 : 0 : }
2207 : :
2208 : : void
2209 : 0 : Dump::visit (SlicePattern &e)
2210 : : {
2211 : 0 : begin ("SlicePattern");
2212 : 0 : do_mappings (e.get_mappings ());
2213 : 0 : visit_collection ("items", e.get_items ());
2214 : 0 : end ("SlicePattern");
2215 : 0 : }
2216 : :
2217 : : void
2218 : 0 : Dump::visit (AltPattern &e)
2219 : : {
2220 : 0 : begin ("AltPattern");
2221 : 0 : do_mappings (e.get_mappings ());
2222 : 0 : visit_collection ("alts", e.get_alts ());
2223 : 0 : end ("AltPattern");
2224 : 0 : }
2225 : :
2226 : : void
2227 : 0 : Dump::visit (EmptyStmt &e)
2228 : : {
2229 : 0 : begin ("EmptyStmt");
2230 : 0 : do_stmt (e);
2231 : 0 : end ("EmptyStmt");
2232 : 0 : }
2233 : :
2234 : : void
2235 : 0 : Dump::visit (LetStmt &e)
2236 : : {
2237 : 0 : begin ("LetStmt");
2238 : 0 : do_stmt (e);
2239 : 0 : auto oa = e.get_outer_attrs ();
2240 : 0 : do_outer_attrs (oa);
2241 : :
2242 : 0 : put_field ("variable_pattern", e.get_pattern ()->as_string ());
2243 : :
2244 : 0 : visit_field ("type", e.get_type ());
2245 : 0 : visit_field ("init_expr", e.get_init_expr ());
2246 : :
2247 : 0 : end ("LetStmt");
2248 : 0 : }
2249 : :
2250 : : void
2251 : 0 : Dump::visit (ExprStmt &e)
2252 : : {
2253 : 0 : begin ("ExprStmt");
2254 : 0 : do_stmt (e);
2255 : 0 : put_field ("must_be_unit", std::to_string (e.is_unit_check_needed ()));
2256 : 0 : visit_field ("expr", e.get_expr ());
2257 : 0 : end ("ExprStmt");
2258 : 0 : }
2259 : :
2260 : : void
2261 : 0 : Dump::visit (TraitBound &e)
2262 : : {
2263 : 0 : begin ("TraitBound");
2264 : 0 : do_mappings (e.get_mappings ());
2265 : 0 : put_field ("in_parens", std::to_string (e.get_in_parens ()));
2266 : 0 : put_field ("polarity", BoundPolarityString (e.get_polarity ()));
2267 : :
2268 : 0 : visit_collection ("for_lifetime", e.get_for_lifetimes ());
2269 : 0 : visit_field ("type_path", e.get_path ());
2270 : :
2271 : 0 : end ("TraitBound");
2272 : 0 : }
2273 : :
2274 : : void
2275 : 0 : Dump::visit (ImplTraitType &e)
2276 : : {
2277 : 0 : begin ("ImplTraitType");
2278 : 0 : do_type (e);
2279 : :
2280 : 0 : visit_collection ("type_param_bounds", e.get_type_param_bounds ());
2281 : :
2282 : 0 : end ("ImplTraitType");
2283 : 0 : }
2284 : :
2285 : : void
2286 : 0 : Dump::visit (TraitObjectType &e)
2287 : : {
2288 : 0 : begin ("TraitObjectType");
2289 : 0 : do_type (e);
2290 : :
2291 : 0 : put_field ("has_dyn", std::to_string (e.get_has_dyn ()));
2292 : :
2293 : 0 : visit_collection ("type_param_bounds", e.get_type_param_bounds ());
2294 : :
2295 : 0 : end ("TraitObjectType");
2296 : 0 : }
2297 : :
2298 : : void
2299 : 0 : Dump::visit (ParenthesisedType &e)
2300 : : {
2301 : 0 : begin ("ParenthesisedType");
2302 : 0 : do_type (e);
2303 : 0 : put_field ("type_in_parens", e.get_type_in_parens ()->as_string ());
2304 : 0 : end ("ParenthesisedType");
2305 : 0 : }
2306 : :
2307 : : void
2308 : 0 : Dump::visit (ImplTraitTypeOneBound &e)
2309 : : {
2310 : 0 : begin ("ImplTraitTypeOneBound");
2311 : 0 : do_type (e);
2312 : 0 : visit_field ("trait_bound", e.get_trait_bound ());
2313 : 0 : end ("ImplTraitTypeOneBound");
2314 : 0 : }
2315 : :
2316 : : void
2317 : 0 : Dump::visit (TupleType &e)
2318 : : {
2319 : 0 : begin ("TupleType");
2320 : 0 : do_type (e);
2321 : 0 : visit_collection ("elems", e.get_elems ());
2322 : 0 : end ("TupleType");
2323 : 0 : }
2324 : :
2325 : : void
2326 : 0 : Dump::visit (NeverType &e)
2327 : : {
2328 : 0 : begin ("NeverType");
2329 : 0 : do_type (e);
2330 : 0 : end ("NeverType");
2331 : 0 : }
2332 : :
2333 : : void
2334 : 0 : Dump::visit (RawPointerType &e)
2335 : : {
2336 : 0 : begin ("RawPointerType");
2337 : 0 : do_type (e);
2338 : 0 : put_field ("mut", Rust::enum_to_str (e.get_mut ()));
2339 : 0 : put_field ("type", e.get_type ()->as_string ());
2340 : 0 : end ("RawPointerType");
2341 : 0 : }
2342 : :
2343 : : void
2344 : 0 : Dump::visit (ReferenceType &e)
2345 : : {
2346 : 0 : begin ("ReferenceType");
2347 : 0 : do_type (e);
2348 : 0 : put_field ("lifetime", e.get_lifetime ().as_string ());
2349 : 0 : put_field ("mut", enum_to_str (e.get_mut ()));
2350 : 0 : put_field ("type", e.get_base_type ()->as_string ());
2351 : 0 : end ("ReferenceType");
2352 : 0 : }
2353 : :
2354 : : void
2355 : 0 : Dump::visit (ArrayType &e)
2356 : : {
2357 : 0 : begin ("ArrayType");
2358 : 0 : do_type (e);
2359 : 0 : visit_field ("type", e.get_element_type ());
2360 : 0 : visit_field ("size", e.get_size_expr ());
2361 : 0 : end ("ArrayType");
2362 : 0 : }
2363 : :
2364 : : void
2365 : 0 : Dump::visit (SliceType &e)
2366 : : {
2367 : 0 : begin ("SliceType");
2368 : 0 : do_type (e);
2369 : 0 : visit_field ("elem_type", e.get_element_type ());
2370 : 0 : end ("SliceType");
2371 : 0 : }
2372 : :
2373 : : void
2374 : 0 : Dump::visit (InferredType &e)
2375 : : {
2376 : 0 : begin ("InferredType");
2377 : 0 : do_type (e);
2378 : 0 : end ("InferredType");
2379 : 0 : }
2380 : :
2381 : : void
2382 : 0 : Dump::visit (BareFunctionType &e)
2383 : : {
2384 : 0 : begin ("BareFunctionType");
2385 : 0 : do_type (e);
2386 : :
2387 : 0 : visit_collection ("for_lifetimes", e.get_for_lifetimes ());
2388 : :
2389 : 0 : put_field ("function_qualifiers", e.get_function_qualifiers ().as_string ());
2390 : :
2391 : 0 : if (e.get_function_params ().empty ())
2392 : : {
2393 : 0 : put_field ("params", "none");
2394 : : }
2395 : : else
2396 : : {
2397 : 0 : begin_field ("params");
2398 : 0 : for (auto ¶m : e.get_function_params ())
2399 : : {
2400 : 0 : begin ("MaybeNamedParam");
2401 : 0 : do_maybenamedparam (param);
2402 : 0 : end ("MaybeNamedParam");
2403 : : }
2404 : 0 : end_field ("params");
2405 : : }
2406 : :
2407 : 0 : visit_field ("return_type", e.get_return_type ());
2408 : 0 : put_field ("is_variadic", std::to_string (e.get_is_variadic ()));
2409 : 0 : end ("BareFunctionType");
2410 : 0 : }
2411 : :
2412 : : } // namespace HIR
2413 : : } // namespace Rust
2414 : :
2415 : : // In the global namespace to make it easier to call from debugger
2416 : : void
2417 : 0 : debug (Rust::HIR::FullVisitable &v)
2418 : : {
2419 : 0 : Rust::HIR::Dump::debug (v);
2420 : 0 : }
|
