gcc/rust/ast/rust-ast-visitor.cc

   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-visitor.h"
  20 #include "rust-ast-full-decls.h"
  21 #include "rust-ast.h"
  22 #include "rust-path.h"
  23 #include "rust-token.h"
  24 #include "rust-expr.h"
  25 #include "rust-macro.h"
  26 #include "rust-pattern.h"
  27 #include "rust-stmt.h"
  28 #include "rust-type.h"
  29
  30 namespace Rust {
  31 namespace AST {
  32
  33 void
  34 DefaultASTVisitor::visit (AST::Crate &crate)
  35 {
  36   visit_inner_attrs (crate);
  37   for (auto &item : crate.items)
  38     visit (item);
  39 }
  40
  41 void
  42 DefaultASTVisitor::visit (AST::Token &tok)
  43 {}
  44
  45 void
  46 DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
  47 {
  48   for (auto &token : delim_tok_tree.get_token_trees ())
  49     visit (token);
  50 }
  51
  52 void
  53 DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
  54 {
  55   for (auto &item : input.get_items ())
  56     visit (item);
  57 }
  58
  59 void
  60 DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
  61 {
  62   visit_outer_attrs (ident_expr);
  63 }
  64
  65 void
  66 DefaultASTVisitor::visit (AST::Lifetime &lifetime)
  67 {}
  68
  69 void
  70 DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
  71 {
  72   visit (lifetime_param.get_outer_attribute ());
  73   visit (lifetime_param.get_lifetime ());
  74   for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
  75     visit (lifetime_bound);
  76 }
  77
  78 void
  79 DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
  80 {
  81   visit (const_param.get_outer_attribute ());
  82   if (const_param.has_type ())
  83     visit (const_param.get_type ());
  84   if (const_param.has_default_value ())
  85     visit (const_param.get_default_value ());
  86 }
  87
  88 void
  89 DefaultASTVisitor::visit (AST::PathInExpression &path)
  90 {
  91   visit_outer_attrs (path);
  92   for (auto &segment : path.get_segments ())
  93     visit (segment);
  94 }
  95
  96 void
  97 DefaultASTVisitor::visit (AST::TypePathSegment &segment)
  98 {}
  99
 100 void
 101 DefaultASTVisitor::visit (GenericArgsBinding &binding)
 102 {
 103   visit (binding.get_type ());
 104 }
 105
 106 void
 107 DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
 108 {
 109   visit (segment.get_generic_args ());
 110 }
 111
 112 void
 113 DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
 114 {
 115   for (auto &input : tpf.get_params ())
 116     visit (input);
 117   if (tpf.has_return_type ())
 118     visit (tpf.get_return_type ());
 119 }
 120
 121 void
 122 DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
 123 {}
 124
 125 void
 126 DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
 127 {
 128   visit (segment.get_type_path_function ());
 129   visit (segment.get_ident_segment ());
 130 }
 131
 132 void
 133 DefaultASTVisitor::visit (AST::GenericArgs &args)
 134 {
 135   for (auto &lifetime : args.get_lifetime_args ())
 136     visit (lifetime);
 137
 138   for (auto &generic : args.get_generic_args ())
 139     visit (generic);
 140
 141   for (auto &binding : args.get_binding_args ())
 142     visit (binding);
 143 }
 144
 145 void
 146 DefaultASTVisitor::visit (AST::PathExprSegment &segment)
 147 {
 148   visit (segment.get_ident_segment ());
 149   if (segment.has_generic_args ())
 150     visit (segment.get_generic_args ());
 151 }
 152 void
 153 DefaultASTVisitor::visit (AST::TypePath &path)
 154 {
 155   for (auto &segment : path.get_segments ())
 156     visit (segment);
 157 }
 158
 159 void
 160 DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
 161 {
 162   visit_outer_attrs (path);
 163   visit (path.get_qualified_path_type ());
 164
 165   for (auto &segment : path.get_segments ())
 166     visit (segment);
 167 }
 168
 169 void
 170 DefaultASTVisitor::visit (AST::QualifiedPathType &path)
 171 {
 172   visit (path.get_type ());
 173   if (path.has_as_clause ())
 174     visit (path.get_as_type_path ());
 175 }
 176
 177 void
 178 DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
 179 {
 180   visit (path.get_qualified_path_type ());
 181   visit (path.get_associated_segment ());
 182
 183   for (auto &segment : path.get_segments ())
 184     visit (segment);
 185 }
 186
 187 void
 188 DefaultASTVisitor::visit (AST::LiteralExpr &expr)
 189 {
 190   visit_outer_attrs (expr);
 191 }
 192
 193 void
 194 DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
 195 {
 196   visit (attr_input.get_literal ());
 197 }
 198
 199 void
 200 DefaultASTVisitor::visit (AST::AttrInputMacro &attr_input)
 201 {
 202   visit (attr_input.get_macro ());
 203 }
 204
 205 void
 206 DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
 207 {
 208   visit (meta_item.get_literal ());
 209 }
 210
 211 void
 212 DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
 213 {}
 214
 215 void
 216 DefaultASTVisitor::visit (AST::SimplePath &path)
 217 {
 218   for (auto &segment : path.get_segments ())
 219     visit (segment);
 220 }
 221
 222 void
 223 DefaultASTVisitor::visit (AST::MetaItemPathLit &meta_item)
 224 {
 225   visit (meta_item.get_path ());
 226   visit (meta_item.get_literal ());
 227 }
 228
 229 void
 230 DefaultASTVisitor::visit (AST::BorrowExpr &expr)
 231 {
 232   visit_outer_attrs (expr);
 233   visit (expr.get_borrowed_expr ());
 234 }
 235
 236 void
 237 DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
 238 {
 239   visit_outer_attrs (expr);
 240   visit (expr.get_dereferenced_expr ());
 241 }
 242
 243 void
 244 DefaultASTVisitor::visit (AST::ErrorPropagationExpr &expr)
 245 {
 246   visit_outer_attrs (expr);
 247 }
 248
 249 void
 250 DefaultASTVisitor::visit (AST::NegationExpr &expr)
 251 {
 252   visit_outer_attrs (expr);
 253   visit (expr.get_negated_expr ());
 254 }
 255
 256 void
 257 DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
 258 {
 259   visit_outer_attrs (expr);
 260   visit (expr.get_left_expr ());
 261   visit (expr.get_right_expr ());
 262 }
 263
 264 void
 265 DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
 266 {
 267   visit_outer_attrs (expr);
 268   visit (expr.get_left_expr ());
 269   visit (expr.get_right_expr ());
 270 }
 271
 272 void
 273 DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
 274 {
 275   visit_outer_attrs (expr);
 276   visit (expr.get_left_expr ());
 277   visit (expr.get_right_expr ());
 278 }
 279
 280 void
 281 DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
 282 {
 283   visit_outer_attrs (expr);
 284   visit (expr.get_casted_expr ());
 285   visit (expr.get_type_to_cast_to ());
 286 }
 287
 288 void
 289 DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
 290 {
 291   visit_outer_attrs (expr);
 292   visit (expr.get_left_expr ());
 293   visit (expr.get_right_expr ());
 294 }
 295
 296 void
 297 DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
 298 {
 299   visit_outer_attrs (expr);
 300   visit (expr.get_left_expr ());
 301   visit (expr.get_right_expr ());
 302 }
 303
 304 void
 305 DefaultASTVisitor::visit (AST::GroupedExpr &expr)
 306 {
 307   visit_outer_attrs (expr);
 308   visit_inner_attrs (expr);
 309   visit (expr.get_expr_in_parens ());
 310 }
 311
 312 void
 313 DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
 314 {
 315   for (auto &value : elems.get_values ())
 316     visit (value);
 317 }
 318
 319 void
 320 DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
 321 {
 322   visit (elems.get_elem_to_copy ());
 323   visit (elems.get_num_copies ());
 324 }
 325
 326 void
 327 DefaultASTVisitor::visit (AST::ArrayExpr &expr)
 328 {
 329   visit_outer_attrs (expr);
 330   visit_inner_attrs (expr);
 331   visit (expr.get_array_elems ());
 332 }
 333
 334 void
 335 DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
 336 {
 337   visit_outer_attrs (expr);
 338   visit (expr.get_array_expr ());
 339   visit (expr.get_index_expr ());
 340 }
 341
 342 void
 343 DefaultASTVisitor::visit (AST::TupleExpr &expr)
 344 {
 345   visit_outer_attrs (expr);
 346   visit_inner_attrs (expr);
 347   for (auto &elem : expr.get_tuple_elems ())
 348     visit (elem);
 349 }
 350
 351 void
 352 DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
 353 {
 354   visit_outer_attrs (expr);
 355   visit (expr.get_tuple_expr ());
 356 }
 357
 358 void
 359 DefaultASTVisitor::visit (AST::StructExprStruct &expr)
 360 {
 361   visit_outer_attrs (expr);
 362   visit_inner_attrs (expr);
 363   visit (expr.get_struct_name ());
 364 }
 365
 366 void
 367 DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
 368 {}
 369
 370 void
 371 DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
 372 {
 373   visit (field.get_value ());
 374 }
 375
 376 void
 377 DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
 378 {
 379   visit (field.get_value ());
 380 }
 381
 382 void
 383 DefaultASTVisitor::visit (AST::StructBase &base)
 384 {
 385   visit (base.get_base_struct ());
 386 }
 387
 388 void
 389 DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
 390 {
 391   visit_outer_attrs (expr);
 392   visit_inner_attrs (expr);
 393   if (expr.has_struct_base ())
 394     visit (expr.get_struct_base ());
 395   for (auto &field : expr.get_fields ())
 396     visit (field);
 397 }
 398
 399 void
 400 DefaultASTVisitor::visit (AST::StructExprStructBase &expr)
 401 {
 402   visit_outer_attrs (expr);
 403   visit_inner_attrs (expr);
 404   visit (expr.get_struct_base ());
 405 }
 406
 407 void
 408 DefaultASTVisitor::visit (AST::CallExpr &expr)
 409 {
 410   visit_outer_attrs (expr);
 411   visit (expr.get_function_expr ());
 412   for (auto &param : expr.get_params ())
 413     visit (param);
 414 }
 415
 416 void
 417 DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
 418 {
 419   visit_outer_attrs (expr);
 420   visit (expr.get_receiver_expr ());
 421   visit (expr.get_method_name ());
 422   for (auto &param : expr.get_params ())
 423     visit (param);
 424 }
 425
 426 void
 427 DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
 428 {
 429   visit_outer_attrs (expr);
 430   visit (expr.get_receiver_expr ());
 431 }
 432
 433 void
 434 DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
 435 {
 436   visit_outer_attrs (expr);
 437   for (auto &param : expr.get_params ())
 438     visit (param);
 439   visit (expr.get_definition_expr ());
 440 }
 441
 442 void
 443 DefaultASTVisitor::visit (AST::BlockExpr &expr)
 444 {
 445   visit_outer_attrs (expr);
 446   visit_inner_attrs (expr);
 447   for (auto &stmt : expr.get_statements ())
 448     visit (stmt);
 449   if (expr.has_tail_expr ())
 450     visit (expr.get_tail_expr ());
 451 }
 452
 453 void
 454 DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
 455 {
 456   visit_outer_attrs (expr);
 457   for (auto &param : expr.get_params ())
 458     visit (param);
 459   visit (expr.get_return_type ());
 460   visit (expr.get_definition_block ());
 461 }
 462
 463 void
 464 DefaultASTVisitor::visit (AST::ClosureParam &param)
 465 {
 466   visit_outer_attrs (param);
 467   visit (param.get_pattern ());
 468   if (param.has_type_given ())
 469     visit (param.get_type ());
 470 }
 471
 472 void
 473 DefaultASTVisitor::visit (AST::ContinueExpr &expr)
 474 {
 475   visit_outer_attrs (expr);
 476   visit (expr.get_label ());
 477 }
 478
 479 void
 480 DefaultASTVisitor::visit (AST::BreakExpr &expr)
 481 {
 482   visit_outer_attrs (expr);
 483   if (expr.has_label ())
 484     visit (expr.get_label ());
 485
 486   if (expr.has_break_expr ())
 487     visit (expr.get_break_expr ());
 488 }
 489
 490 void
 491 DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
 492 {
 493   visit (expr.get_from_expr ());
 494   visit (expr.get_to_expr ());
 495 }
 496
 497 void
 498 DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
 499 {
 500   visit (expr.get_from_expr ());
 501 }
 502
 503 void
 504 DefaultASTVisitor::visit (AST::RangeToExpr &expr)
 505 {
 506   visit (expr.get_to_expr ());
 507 }
 508
 509 void
 510 DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
 511 {}
 512
 513 void
 514 DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
 515 {
 516   visit (expr.get_from_expr ());
 517   visit (expr.get_to_expr ());
 518 }
 519
 520 void
 521 DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
 522 {
 523   visit (expr.get_to_expr ());
 524 }
 525
 526 void
 527 DefaultASTVisitor::visit (AST::ReturnExpr &expr)
 528 {
 529   visit_outer_attrs (expr);
 530   if (expr.has_returned_expr ())
 531     visit (expr.get_returned_expr ());
 532 }
 533
 534 void
 535 DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
 536 {
 537   visit_outer_attrs (expr);
 538   visit (expr.get_block_expr ());
 539 }
 540
 541 void
 542 DefaultASTVisitor::visit (AST::LoopLabel &label)
 543 {
 544   visit (label.get_lifetime ());
 545 }
 546
 547 void
 548 DefaultASTVisitor::visit (AST::LoopExpr &expr)
 549 {
 550   visit_outer_attrs (expr);
 551   visit (expr.get_loop_label ());
 552   visit (expr.get_loop_block ());
 553 }
 554
 555 void
 556 DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
 557 {
 558   visit_outer_attrs (expr);
 559   visit (expr.get_predicate_expr ());
 560   visit (expr.get_loop_label ());
 561   visit (expr.get_loop_block ());
 562 }
 563
 564 void
 565 DefaultASTVisitor::visit (AST::WhileLetLoopExpr &expr)
 566 {
 567   visit_outer_attrs (expr);
 568   for (auto &pattern : expr.get_patterns ())
 569     visit (pattern);
 570   visit (expr.get_scrutinee_expr ());
 571   visit (expr.get_loop_label ());
 572   visit (expr.get_loop_block ());
 573 }
 574
 575 void
 576 DefaultASTVisitor::visit (AST::ForLoopExpr &expr)
 577 {
 578   visit_outer_attrs (expr);
 579   visit (expr.get_pattern ());
 580   visit (expr.get_iterator_expr ());
 581   visit (expr.get_loop_label ());
 582   visit (expr.get_loop_block ());
 583 }
 584
 585 void
 586 DefaultASTVisitor::visit (AST::IfExpr &expr)
 587 {
 588   visit_outer_attrs (expr);
 589   visit (expr.get_condition_expr ());
 590   visit (expr.get_if_block ());
 591 }
 592
 593 void
 594 DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
 595 {
 596   visit (reinterpret_cast<AST::IfExpr &> (expr));
 597   visit (expr.get_else_block ());
 598 }
 599
 600 void
 601 DefaultASTVisitor::visit (AST::IfLetExpr &expr)
 602 {
 603   visit_outer_attrs (expr);
 604   for (auto &pattern : expr.get_patterns ())
 605     visit (pattern);
 606   visit (expr.get_value_expr ());
 607   visit (expr.get_if_block ());
 608 }
 609
 610 void
 611 DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
 612 {
 613   visit (reinterpret_cast<AST::IfLetExpr &> (expr));
 614   visit (expr.get_else_block ());
 615 }
 616
 617 void
 618 DefaultASTVisitor::visit (AST::MatchArm &arm)
 619 {
 620   visit_outer_attrs (arm);
 621   for (auto &pattern : arm.get_patterns ())
 622     visit (pattern);
 623   if (arm.has_match_arm_guard ())
 624     visit (arm.get_guard_expr ());
 625 }
 626
 627 void
 628 DefaultASTVisitor::visit (AST::MatchCase &arm)
 629 {
 630   visit (arm.get_arm ());
 631   visit (arm.get_expr ());
 632 }
 633
 634 void
 635 DefaultASTVisitor::visit (AST::MatchExpr &expr)
 636 {
 637   visit_outer_attrs (expr);
 638   visit_inner_attrs (expr);
 639   visit (expr.get_scrutinee_expr ());
 640   for (auto &arm : expr.get_match_cases ())
 641     visit (arm);
 642 }
 643
 644 void
 645 DefaultASTVisitor::visit (AST::AwaitExpr &expr)
 646 {
 647   visit_outer_attrs (expr);
 648   visit (expr.get_awaited_expr ());
 649 }
 650
 651 void
 652 DefaultASTVisitor::visit (AST::AsyncBlockExpr &expr)
 653 {
 654   visit_outer_attrs (expr);
 655   visit (expr.get_block_expr ());
 656 }
 657
 658 void
 659 DefaultASTVisitor::visit (AST::TypeParam &param)
 660 {
 661   visit (param.get_outer_attribute ());
 662   for (auto &bound : param.get_type_param_bounds ())
 663     visit (bound);
 664   if (param.has_type ())
 665     visit (param.get_type ());
 666 }
 667
 668 void
 669 DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
 670 {
 671   visit (item.get_lifetime ());
 672   for (auto &bound : item.get_lifetime_bounds ())
 673     visit (bound);
 674 }
 675
 676 void
 677 DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
 678 {
 679   for (auto &lifetime : item.get_for_lifetimes ())
 680     visit (lifetime);
 681   visit (item.get_type ());
 682   for (auto &param : item.get_type_param_bounds ())
 683     visit (param);
 684 }
 685
 686 void
 687 DefaultASTVisitor::visit (AST::Visibility &vis)
 688 {
 689   visit (vis.get_path ());
 690 }
 691
 692 void
 693 DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
 694 {}
 695
 696 void
 697 DefaultASTVisitor::visit (AST::WhereClause &where)
 698 {
 699   for (auto &item : where.get_items ())
 700     visit (item);
 701 }
 702 void
 703 DefaultASTVisitor::visit (AST::FunctionParam &param)
 704 {
 705   visit_outer_attrs (param);
 706   if (param.has_name ())
 707     visit (param.get_pattern ());
 708
 709   visit (param.get_type ());
 710 }
 711
 712 void
 713 DefaultASTVisitor::visit (AST::SelfParam &param)
 714 {
 715   visit_outer_attrs (param);
 716
 717   if (param.has_lifetime ())
 718     visit (param.get_lifetime ());
 719
 720   if (param.has_type ())
 721     visit (param.get_type ());
 722 }
 723
 724 void
 725 DefaultASTVisitor::visit (AST::Module &module)
 726 {
 727   visit_outer_attrs (module);
 728   visit (module.get_visibility ());
 729   visit_inner_attrs (module);
 730   for (auto &item : module.get_items ())
 731     visit (item);
 732 }
 733
 734 void
 735 DefaultASTVisitor::visit (AST::ExternCrate &crate)
 736 {
 737   visit_outer_attrs (crate);
 738   visit (crate.get_visibility ());
 739 }
 740
 741 void
 742 DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
 743 {
 744   visit (use_tree.get_path ());
 745 }
 746
 747 void
 748 DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
 749 {
 750   visit (use_tree.get_path ());
 751 }
 752
 753 void
 754 DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
 755 {
 756   visit (use_tree.get_path ());
 757 }
 758
 759 void
 760 DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
 761 {
 762   visit (use_decl.get_tree ());
 763 }
 764
 765 void
 766 DefaultASTVisitor::visit (AST::Function &function)
 767 {
 768   visit_outer_attrs (function);
 769   visit (function.get_visibility ());
 770   visit (function.get_qualifiers ());
 771   for (auto &generic : function.get_generic_params ())
 772     visit (generic);
 773   if (function.has_self_param ())
 774     visit (function.get_self_param ());
 775   for (auto &param : function.get_function_params ())
 776     visit (param);
 777   if (function.has_return_type ())
 778     visit (function.get_return_type ());
 779   if (function.has_where_clause ())
 780     visit (function.get_where_clause ());
 781   if (function.has_body ())
 782     visit (*function.get_definition ());
 783 }
 784
 785 void
 786 DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
 787 {
 788   visit_outer_attrs (type_alias);
 789   visit (type_alias.get_visibility ());
 790   for (auto &generic : type_alias.get_generic_params ())
 791     visit (generic);
 792   if (type_alias.has_where_clause ())
 793     visit (type_alias.get_where_clause ());
 794   visit (type_alias.get_type_aliased ());
 795 }
 796
 797 void
 798 DefaultASTVisitor::visit (AST::StructField &field)
 799 {
 800   visit_outer_attrs (field);
 801   visit (field.get_visibility ());
 802   visit (field.get_field_type ());
 803 }
 804
 805 void
 806 DefaultASTVisitor::visit (AST::StructStruct &struct_item)
 807 {
 808   visit_outer_attrs (struct_item);
 809   visit (struct_item.get_visibility ());
 810   for (auto &generic : struct_item.get_generic_params ())
 811     visit (generic);
 812   if (struct_item.has_where_clause ())
 813     visit (struct_item.get_where_clause ());
 814   for (auto &field : struct_item.get_fields ())
 815     visit (field);
 816 }
 817
 818 void
 819 DefaultASTVisitor::visit (AST::TupleField &field)
 820 {
 821   visit_outer_attrs (field);
 822   visit (field.get_visibility ());
 823   visit (field.get_field_type ());
 824 }
 825
 826 void
 827 DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
 828 {
 829   visit_outer_attrs (tuple_struct);
 830   visit (tuple_struct.get_visibility ());
 831   for (auto &generic : tuple_struct.get_generic_params ())
 832     visit (generic);
 833   if (tuple_struct.has_where_clause ())
 834     visit (tuple_struct.get_where_clause ());
 835   for (auto &field : tuple_struct.get_fields ())
 836     visit (field);
 837 }
 838
 839 void
 840 DefaultASTVisitor::visit (AST::EnumItem &item)
 841 {
 842   visit_outer_attrs (item);
 843   visit (item.get_visibility ());
 844 }
 845
 846 void
 847 DefaultASTVisitor::visit (AST::EnumItemTuple &item)
 848 {
 849   visit (reinterpret_cast<EnumItem &> (item));
 850   for (auto &field : item.get_tuple_fields ())
 851     visit (field);
 852 }
 853
 854 void
 855 DefaultASTVisitor::visit (AST::EnumItemStruct &item)
 856 {
 857   visit (reinterpret_cast<EnumItem &> (item));
 858   for (auto &field : item.get_struct_fields ())
 859     visit (field);
 860 }
 861
 862 void
 863 DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
 864 {
 865   visit (reinterpret_cast<EnumItem &> (item));
 866   visit (item.get_expr ());
 867 }
 868
 869 void
 870 DefaultASTVisitor::visit (AST::Enum &enum_item)
 871 {
 872   visit_outer_attrs (enum_item);
 873   visit (enum_item.get_visibility ());
 874   for (auto &generic : enum_item.get_generic_params ())
 875     visit (generic);
 876   if (enum_item.has_where_clause ())
 877     visit (enum_item.get_where_clause ());
 878   for (auto &item : enum_item.get_variants ())
 879     visit (item);
 880 }
 881
 882 void
 883 DefaultASTVisitor::visit (AST::Union &union_item)
 884 {
 885   visit_outer_attrs (union_item);
 886   visit (union_item.get_visibility ());
 887   for (auto &generic : union_item.get_generic_params ())
 888     visit (generic);
 889   if (union_item.has_where_clause ())
 890     visit (union_item.get_where_clause ());
 891   for (auto &variant : union_item.get_variants ())
 892     visit (variant);
 893 }
 894
 895 void
 896 DefaultASTVisitor::visit (AST::ConstantItem &const_item)
 897 {
 898   visit_outer_attrs (const_item);
 899   visit (const_item.get_visibility ());
 900   visit (const_item.get_type ());
 901   if (const_item.has_expr ())
 902     visit (const_item.get_expr ());
 903 }
 904
 905 void
 906 DefaultASTVisitor::visit (AST::StaticItem &static_item)
 907 {
 908   visit_outer_attrs (static_item);
 909   visit (static_item.get_visibility ());
 910   visit (static_item.get_type ());
 911   visit (static_item.get_expr ());
 912 }
 913
 914 void
 915 DefaultASTVisitor::visit (AST::TraitItemConst &item)
 916 {
 917   visit_outer_attrs (item);
 918   visit (item.get_type ());
 919   if (item.has_expr ())
 920     visit (item.get_expr ());
 921 }
 922
 923 void
 924 DefaultASTVisitor::visit (AST::TraitItemType &item)
 925 {
 926   visit_outer_attrs (item);
 927   for (auto &bound : item.get_type_param_bounds ())
 928     visit (bound);
 929 }
 930
 931 void
 932 DefaultASTVisitor::visit (AST::Trait &trait)
 933 {
 934   visit_outer_attrs (trait);
 935   visit (trait.get_visibility ());
 936
 937   visit_inner_attrs (trait);
 938
 939   for (auto &generic : trait.get_generic_params ())
 940     visit (generic);
 941
 942   if (trait.has_where_clause ())
 943     visit (trait.get_where_clause ());
 944
 945   for (auto &bound : trait.get_type_param_bounds ())
 946     visit (bound);
 947
 948   for (auto &item : trait.get_trait_items ())
 949     visit (item);
 950 }
 951
 952 void
 953 DefaultASTVisitor::visit (AST::InherentImpl &impl)
 954 {
 955   visit_outer_attrs (impl);
 956   visit (impl.get_visibility ());
 957
 958   for (auto &generic : impl.get_generic_params ())
 959     visit (generic);
 960   if (impl.has_where_clause ())
 961     visit (impl.get_where_clause ());
 962   visit (impl.get_type ());
 963   visit_inner_attrs (impl);
 964   for (auto &item : impl.get_impl_items ())
 965     visit (item);
 966 }
 967
 968 void
 969 DefaultASTVisitor::visit (AST::TraitImpl &impl)
 970 {
 971   visit_outer_attrs (impl);
 972   visit (impl.get_visibility ());
 973
 974   for (auto &generic : impl.get_generic_params ())
 975     visit (generic);
 976   if (impl.has_where_clause ())
 977     visit (impl.get_where_clause ());
 978   visit (impl.get_type ());
 979   visit_inner_attrs (impl);
 980   for (auto &item : impl.get_impl_items ())
 981     visit (item);
 982 }
 983
 984 void
 985 DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
 986 {
 987   visit_outer_attrs (item);
 988   visit (item.get_visibility ());
 989 }
 990
 991 void
 992 DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
 993 {
 994   visit_outer_attrs (item);
 995   visit (item.get_visibility ());
 996   visit (item.get_type ());
 997 }
 998
 999 void
1000 DefaultASTVisitor::visit (AST::NamedFunctionParam &param)
1001 {
1002   visit_outer_attrs (param);
1003   if (!param.is_variadic ())
1004     visit (param.get_type ());
1005 }
1006
1007 void
1008 DefaultASTVisitor::visit (AST::ExternBlock &block)
1009 {
1010   visit_outer_attrs (block);
1011   visit (block.get_visibility ());
1012   visit_inner_attrs (block);
1013   for (auto &item : block.get_extern_items ())
1014     visit (item);
1015 }
1016
1017 void
1018 DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1019 {}
1020
1021 void
1022 DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1023 {
1024   for (auto &m : match.get_matches ())
1025     visit (m);
1026 }
1027
1028 void
1029 DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1030 {
1031   for (auto &m : matcher.get_matches ())
1032     visit (m);
1033 }
1034
1035 void
1036 DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1037 {
1038   visit (transcriber.get_token_tree ());
1039 }
1040
1041 void
1042 DefaultASTVisitor::visit (AST::MacroRule &rule)
1043 {
1044   visit (rule.get_matcher ());
1045   visit (rule.get_transcriber ());
1046 }
1047 void
1048 DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1049 {
1050   visit_outer_attrs (rules_def);
1051   for (auto &rule : rules_def.get_macro_rules ())
1052     visit (rule);
1053 }
1054
1055 void
1056 DefaultASTVisitor::visit (AST::MacroInvocData &data)
1057 {
1058   visit (data.get_path ());
1059   visit (data.get_delim_tok_tree ());
1060 }
1061 void
1062 DefaultASTVisitor::visit (AST::MacroInvocation &macro_invoc)
1063 {
1064   visit_outer_attrs (macro_invoc);
1065   visit (macro_invoc.get_invoc_data ());
1066 }
1067
1068 void
1069 DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1070 {
1071   visit (meta_item.get_path ());
1072 }
1073
1074 void
1075 DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1076 {
1077   visit (meta_item.get_path ());
1078   for (auto &inner : meta_item.get_seq ())
1079     visit (inner);
1080 }
1081
1082 void
1083 DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1084 {}
1085
1086 void
1087 DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1088 {}
1089
1090 void
1091 DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1092 {
1093   for (auto &path : meta_item.get_paths ())
1094     visit (path);
1095 }
1096
1097 void
1098 DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1099 {
1100   for (auto &str : meta_item.get_values ())
1101     visit (str);
1102 }
1103
1104 void
1105 DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1106 {}
1107
1108 void
1109 DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1110 {
1111   if (pattern.has_pattern_to_bind ())
1112     visit (pattern.get_pattern_to_bind ());
1113 }
1114
1115 void
1116 DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1117 {}
1118
1119 void
1120 DefaultASTVisitor::visit (AST::RestPattern &pattern)
1121 {}
1122
1123 void
1124 DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1125 {}
1126
1127 void
1128 DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1129 {
1130   visit (bound.get_path ());
1131 }
1132
1133 void
1134 DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1135 {
1136   visit (bound.get_qualified_path ());
1137 }
1138
1139 void
1140 DefaultASTVisitor::visit (AST::RangePattern &pattern)
1141 {
1142   if (pattern.get_has_lower_bound ())
1143     visit (pattern.get_lower_bound ());
1144   if (pattern.get_has_upper_bound ())
1145     visit (pattern.get_upper_bound ());
1146 }
1147
1148 void
1149 DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1150 {
1151   visit (pattern.get_referenced_pattern ());
1152 }
1153
1154 void
1155 DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1156 {
1157   visit_outer_attrs (field);
1158   visit (field.get_index_pattern ());
1159 }
1160
1161 void
1162 DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1163 {
1164   visit_outer_attrs (field);
1165   visit (field.get_ident_pattern ());
1166 }
1167
1168 void
1169 DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1170 {
1171   visit_outer_attrs (field);
1172 }
1173
1174 void
1175 DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1176 {
1177   for (auto &field : spe.get_struct_pattern_fields ())
1178     visit (field);
1179   for (auto &attribute : spe.get_etc_outer_attrs ())
1180     visit (attribute);
1181 }
1182
1183 void
1184 DefaultASTVisitor::visit (AST::StructPattern &pattern)
1185 {
1186   visit (pattern.get_path ());
1187   visit (pattern.get_struct_pattern_elems ());
1188 }
1189
1190 void
1191 DefaultASTVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
1192 {
1193   for (auto &pattern : tuple_items.get_patterns ())
1194     visit (pattern);
1195 }
1196
1197 void
1198 DefaultASTVisitor::visit (AST::TupleStructItemsRange &tuple_items)
1199 {
1200   for (auto &lower : tuple_items.get_lower_patterns ())
1201     visit (lower);
1202   for (auto &upper : tuple_items.get_upper_patterns ())
1203     visit (upper);
1204 }
1205
1206 void
1207 DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1208 {
1209   visit (pattern.get_path ());
1210   visit (pattern.get_items ());
1211 }
1212
1213 void
1214 DefaultASTVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
1215 {
1216   for (auto &pattern : tuple_items.get_patterns ())
1217     visit (pattern);
1218 }
1219
1220 void
1221 DefaultASTVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
1222 {
1223   for (auto &lower : tuple_items.get_lower_patterns ())
1224     visit (lower);
1225   for (auto &upper : tuple_items.get_upper_patterns ())
1226     visit (upper);
1227 }
1228
1229 void
1230 DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1231 {
1232   visit (pattern.get_items ());
1233 }
1234
1235 void
1236 DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1237 {
1238   visit (pattern.get_pattern_in_parens ());
1239 }
1240
1241 void
1242 DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1243 {
1244   for (auto &item : pattern.get_items ())
1245     visit (item);
1246 }
1247
1248 void
1249 DefaultASTVisitor::visit (AST::AltPattern &pattern)
1250 {
1251   for (auto &alt : pattern.get_alts ())
1252     visit (alt);
1253 }
1254
1255 void
1256 DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1257 {}
1258
1259 void
1260 DefaultASTVisitor::visit (AST::LetStmt &stmt)
1261 {
1262   visit_outer_attrs (stmt);
1263   visit (stmt.get_pattern ());
1264   if (stmt.has_type ())
1265     visit (stmt.get_type ());
1266   if (stmt.has_init_expr ())
1267     visit (stmt.get_init_expr ());
1268 }
1269
1270 void
1271 DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1272 {
1273   visit (stmt.get_expr ());
1274 }
1275
1276 void
1277 DefaultASTVisitor::visit (AST::TraitBound &bound)
1278 {
1279   for (auto &lifetime : bound.get_for_lifetimes ())
1280     visit (lifetime);
1281   visit (bound.get_type_path ());
1282 }
1283
1284 void
1285 DefaultASTVisitor::visit (AST::ImplTraitType &type)
1286 {
1287   for (auto &bound : type.get_type_param_bounds ())
1288     visit (bound);
1289 }
1290
1291 void
1292 DefaultASTVisitor::visit (AST::TraitObjectType &type)
1293 {
1294   for (auto &bound : type.get_type_param_bounds ())
1295     visit (bound);
1296 }
1297
1298 void
1299 DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1300 {
1301   visit (type.get_type_in_parens ());
1302 }
1303
1304 void
1305 DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1306 {
1307   visit (type.get_trait_bound ());
1308 }
1309
1310 void
1311 DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1312 {
1313   visit (type.get_trait_bound ());
1314 }
1315
1316 void
1317 DefaultASTVisitor::visit (AST::TupleType &type)
1318 {
1319   for (auto &elem : type.get_elems ())
1320     visit (elem);
1321 }
1322
1323 void
1324 DefaultASTVisitor::visit (AST::NeverType &type)
1325 {}
1326
1327 void
1328 DefaultASTVisitor::visit (AST::RawPointerType &type)
1329 {
1330   visit (type.get_type_pointed_to ());
1331 }
1332
1333 void
1334 DefaultASTVisitor::visit (AST::ReferenceType &type)
1335 {
1336   visit (type.get_lifetime ());
1337   visit (type.get_base_type ());
1338 }
1339
1340 void
1341 DefaultASTVisitor::visit (AST::ArrayType &type)
1342 {
1343   visit (type.get_elem_type ());
1344   visit (type.get_size_expr ());
1345 }
1346
1347 void
1348 DefaultASTVisitor::visit (AST::SliceType &type)
1349 {
1350   visit (type.get_elem_type ());
1351 }
1352
1353 void
1354 DefaultASTVisitor::visit (AST::InferredType &type)
1355 {}
1356
1357 void
1358 DefaultASTVisitor::visit (AST::MaybeNamedParam &param)
1359 {
1360   visit_outer_attrs (param);
1361   visit (param.get_type ());
1362 }
1363
1364 void
1365 DefaultASTVisitor::visit (AST::BareFunctionType &type)
1366 {
1367   for (auto &lifetime : type.get_for_lifetimes ())
1368     visit (lifetime);
1369   visit (type.get_function_qualifiers ());
1370   for (auto &param : type.get_function_params ())
1371     visit (param);
1372   if (type.is_variadic ())
1373     for (auto attr : type.get_variadic_attr ())
1374       visit (attr);
1375   if (type.has_return_type ())
1376     visit (type.get_return_type ());
1377 }
1378
1379 void
1380 DefaultASTVisitor::visit (AST::FormatArgs &)
1381 {
1382   // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1383 }
1384
1385 void
1386 DefaultASTVisitor::visit (AST::VariadicParam &param)
1387 {
1388   if (param.has_pattern ())
1389     visit (param.get_pattern ());
1390 }
1391
1392 void
1393 ContextualASTVisitor::visit (AST::Crate &crate)
1394 {
1395   push_context (Context::CRATE);
1396   DefaultASTVisitor::visit (crate);
1397   pop_context ();
1398 }
1399
1400 void
1401 ContextualASTVisitor::visit (AST::InherentImpl &impl)
1402 {
1403   push_context (Context::INHERENT_IMPL);
1404   DefaultASTVisitor::visit (impl);
1405   pop_context ();
1406 }
1407
1408 void
1409 ContextualASTVisitor::visit (AST::TraitImpl &impl)
1410 {
1411   push_context (Context::TRAIT_IMPL);
1412   DefaultASTVisitor::visit (impl);
1413   pop_context ();
1414 }
1415
1416 void
1417 ContextualASTVisitor::visit (AST::Trait &trait)
1418 {
1419   push_context (Context::TRAIT);
1420   DefaultASTVisitor::visit (trait);
1421   pop_context ();
1422 }
1423
1424 } // namespace AST
1425 } // namespace Rust