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

   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-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::ExternalFunctionItem &item)
1009 {
1010   visit_outer_attrs (item);
1011   visit (item.get_visibility ());
1012   for (auto &generic : item.get_generic_params ())
1013     visit (generic);
1014
1015   if (item.has_where_clause ())
1016     visit (item.get_where_clause ());
1017
1018   for (auto &param : item.get_function_params ())
1019     visit (param);
1020
1021   if (item.has_return_type ())
1022     visit (item.get_return_type ());
1023 }
1024
1025 void
1026 DefaultASTVisitor::visit (AST::ExternBlock &block)
1027 {
1028   visit_outer_attrs (block);
1029   visit (block.get_visibility ());
1030   visit_inner_attrs (block);
1031   for (auto &item : block.get_extern_items ())
1032     visit (item);
1033 }
1034
1035 void
1036 DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1037 {}
1038
1039 void
1040 DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1041 {
1042   for (auto &m : match.get_matches ())
1043     visit (m);
1044 }
1045
1046 void
1047 DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1048 {
1049   for (auto &m : matcher.get_matches ())
1050     visit (m);
1051 }
1052
1053 void
1054 DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1055 {
1056   visit (transcriber.get_token_tree ());
1057 }
1058
1059 void
1060 DefaultASTVisitor::visit (AST::MacroRule &rule)
1061 {
1062   visit (rule.get_matcher ());
1063   visit (rule.get_transcriber ());
1064 }
1065 void
1066 DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1067 {
1068   visit_outer_attrs (rules_def);
1069   for (auto &rule : rules_def.get_macro_rules ())
1070     visit (rule);
1071 }
1072
1073 void
1074 DefaultASTVisitor::visit (AST::MacroInvocData &data)
1075 {
1076   visit (data.get_path ());
1077   visit (data.get_delim_tok_tree ());
1078 }
1079 void
1080 DefaultASTVisitor::visit (AST::MacroInvocation &macro_invoc)
1081 {
1082   visit_outer_attrs (macro_invoc);
1083   visit (macro_invoc.get_invoc_data ());
1084 }
1085
1086 void
1087 DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1088 {
1089   visit (meta_item.get_path ());
1090 }
1091
1092 void
1093 DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1094 {
1095   visit (meta_item.get_path ());
1096   for (auto &inner : meta_item.get_seq ())
1097     visit (inner);
1098 }
1099
1100 void
1101 DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1102 {}
1103
1104 void
1105 DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1106 {}
1107
1108 void
1109 DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1110 {
1111   for (auto &path : meta_item.get_paths ())
1112     visit (path);
1113 }
1114
1115 void
1116 DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1117 {
1118   for (auto &str : meta_item.get_values ())
1119     visit (str);
1120 }
1121
1122 void
1123 DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1124 {}
1125
1126 void
1127 DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1128 {
1129   if (pattern.has_pattern_to_bind ())
1130     visit (pattern.get_pattern_to_bind ());
1131 }
1132
1133 void
1134 DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1135 {}
1136
1137 void
1138 DefaultASTVisitor::visit (AST::RestPattern &pattern)
1139 {}
1140
1141 void
1142 DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1143 {}
1144
1145 void
1146 DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1147 {
1148   visit (bound.get_path ());
1149 }
1150
1151 void
1152 DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1153 {
1154   visit (bound.get_qualified_path ());
1155 }
1156
1157 void
1158 DefaultASTVisitor::visit (AST::RangePattern &pattern)
1159 {
1160   if (pattern.get_has_lower_bound ())
1161     visit (pattern.get_lower_bound ());
1162   if (pattern.get_has_upper_bound ())
1163     visit (pattern.get_upper_bound ());
1164 }
1165
1166 void
1167 DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1168 {
1169   visit (pattern.get_referenced_pattern ());
1170 }
1171
1172 void
1173 DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1174 {
1175   visit_outer_attrs (field);
1176   visit (field.get_index_pattern ());
1177 }
1178
1179 void
1180 DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1181 {
1182   visit_outer_attrs (field);
1183   visit (field.get_ident_pattern ());
1184 }
1185
1186 void
1187 DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1188 {
1189   visit_outer_attrs (field);
1190 }
1191
1192 void
1193 DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1194 {
1195   for (auto &field : spe.get_struct_pattern_fields ())
1196     visit (field);
1197   for (auto &attribute : spe.get_etc_outer_attrs ())
1198     visit (attribute);
1199 }
1200
1201 void
1202 DefaultASTVisitor::visit (AST::StructPattern &pattern)
1203 {
1204   visit (pattern.get_path ());
1205   visit (pattern.get_struct_pattern_elems ());
1206 }
1207
1208 void
1209 DefaultASTVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
1210 {
1211   for (auto &pattern : tuple_items.get_patterns ())
1212     visit (pattern);
1213 }
1214
1215 void
1216 DefaultASTVisitor::visit (AST::TupleStructItemsRange &tuple_items)
1217 {
1218   for (auto &lower : tuple_items.get_lower_patterns ())
1219     visit (lower);
1220   for (auto &upper : tuple_items.get_upper_patterns ())
1221     visit (upper);
1222 }
1223
1224 void
1225 DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1226 {
1227   visit (pattern.get_path ());
1228   if (pattern.has_items ())
1229     visit (pattern.get_items ());
1230 }
1231
1232 void
1233 DefaultASTVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
1234 {
1235   for (auto &pattern : tuple_items.get_patterns ())
1236     visit (pattern);
1237 }
1238
1239 void
1240 DefaultASTVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
1241 {
1242   for (auto &lower : tuple_items.get_lower_patterns ())
1243     visit (lower);
1244   for (auto &upper : tuple_items.get_upper_patterns ())
1245     visit (upper);
1246 }
1247
1248 void
1249 DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1250 {
1251   visit (pattern.get_items ());
1252 }
1253
1254 void
1255 DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1256 {
1257   visit (pattern.get_pattern_in_parens ());
1258 }
1259
1260 void
1261 DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1262 {
1263   for (auto &item : pattern.get_items ())
1264     visit (item);
1265 }
1266
1267 void
1268 DefaultASTVisitor::visit (AST::AltPattern &pattern)
1269 {
1270   for (auto &alt : pattern.get_alts ())
1271     visit (alt);
1272 }
1273
1274 void
1275 DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1276 {}
1277
1278 void
1279 DefaultASTVisitor::visit (AST::LetStmt &stmt)
1280 {
1281   visit_outer_attrs (stmt);
1282   visit (stmt.get_pattern ());
1283   if (stmt.has_type ())
1284     visit (stmt.get_type ());
1285   if (stmt.has_init_expr ())
1286     visit (stmt.get_init_expr ());
1287 }
1288
1289 void
1290 DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1291 {
1292   visit (stmt.get_expr ());
1293 }
1294
1295 void
1296 DefaultASTVisitor::visit (AST::TraitBound &bound)
1297 {
1298   for (auto &lifetime : bound.get_for_lifetimes ())
1299     visit (lifetime);
1300   visit (bound.get_type_path ());
1301 }
1302
1303 void
1304 DefaultASTVisitor::visit (AST::ImplTraitType &type)
1305 {
1306   for (auto &bound : type.get_type_param_bounds ())
1307     visit (bound);
1308 }
1309
1310 void
1311 DefaultASTVisitor::visit (AST::TraitObjectType &type)
1312 {
1313   for (auto &bound : type.get_type_param_bounds ())
1314     visit (bound);
1315 }
1316
1317 void
1318 DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1319 {
1320   visit (type.get_type_in_parens ());
1321 }
1322
1323 void
1324 DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1325 {
1326   visit (type.get_trait_bound ());
1327 }
1328
1329 void
1330 DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1331 {
1332   visit (type.get_trait_bound ());
1333 }
1334
1335 void
1336 DefaultASTVisitor::visit (AST::TupleType &type)
1337 {
1338   for (auto &elem : type.get_elems ())
1339     visit (elem);
1340 }
1341
1342 void
1343 DefaultASTVisitor::visit (AST::NeverType &type)
1344 {}
1345
1346 void
1347 DefaultASTVisitor::visit (AST::RawPointerType &type)
1348 {
1349   visit (type.get_type_pointed_to ());
1350 }
1351
1352 void
1353 DefaultASTVisitor::visit (AST::ReferenceType &type)
1354 {
1355   visit (type.get_lifetime ());
1356   visit (type.get_base_type ());
1357 }
1358
1359 void
1360 DefaultASTVisitor::visit (AST::ArrayType &type)
1361 {
1362   visit (type.get_elem_type ());
1363   visit (type.get_size_expr ());
1364 }
1365
1366 void
1367 DefaultASTVisitor::visit (AST::SliceType &type)
1368 {
1369   visit (type.get_elem_type ());
1370 }
1371
1372 void
1373 DefaultASTVisitor::visit (AST::InferredType &type)
1374 {}
1375
1376 void
1377 DefaultASTVisitor::visit (AST::MaybeNamedParam &param)
1378 {
1379   visit_outer_attrs (param);
1380   visit (param.get_type ());
1381 }
1382
1383 void
1384 DefaultASTVisitor::visit (AST::BareFunctionType &type)
1385 {
1386   for (auto &lifetime : type.get_for_lifetimes ())
1387     visit (lifetime);
1388   visit (type.get_function_qualifiers ());
1389   for (auto &param : type.get_function_params ())
1390     visit (param);
1391   if (type.is_variadic ())
1392     for (auto attr : type.get_variadic_attr ())
1393       visit (attr);
1394   if (type.has_return_type ())
1395     visit (type.get_return_type ());
1396 }
1397
1398 void
1399 DefaultASTVisitor::visit (AST::VariadicParam &param)
1400 {
1401   if (param.has_pattern ())
1402     visit (param.get_pattern ());
1403 }
1404
1405 void
1406 ContextualASTVisitor::visit (AST::Crate &crate)
1407 {
1408   push_context (Context::CRATE);
1409   DefaultASTVisitor::visit (crate);
1410   pop_context ();
1411 }
1412
1413 void
1414 ContextualASTVisitor::visit (AST::InherentImpl &impl)
1415 {
1416   push_context (Context::INHERENT_IMPL);
1417   DefaultASTVisitor::visit (impl);
1418   pop_context ();
1419 }
1420
1421 void
1422 ContextualASTVisitor::visit (AST::TraitImpl &impl)
1423 {
1424   push_context (Context::TRAIT_IMPL);
1425   DefaultASTVisitor::visit (impl);
1426   pop_context ();
1427 }
1428
1429 void
1430 ContextualASTVisitor::visit (AST::Trait &trait)
1431 {
1432   push_context (Context::TRAIT);
1433   DefaultASTVisitor::visit (trait);
1434   pop_context ();
1435 }
1436
1437 } // namespace AST
1438 } // namespace Rust