LCOV - code coverage report
Current view: top level - gcc/rust/ast - rust-ast-visitor.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 93.9 % 942 885
Test Date: 2026-11-14 16:39:50 Functions: 95.3 % 190 181
Legend: Lines:     hit not hit

            Line data    Source code
       1              : // Copyright (C) 2020-2026 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-builtin-ast-nodes.h"
      23              : #include "rust-path.h"
      24              : #include "rust-token.h"
      25              : #include "rust-expr.h"
      26              : #include "rust-macro.h"
      27              : #include "rust-pattern.h"
      28              : #include "rust-stmt.h"
      29              : #include "rust-type.h"
      30              : 
      31              : namespace Rust {
      32              : namespace AST {
      33              : 
      34              : void
      35        96625 : DefaultASTVisitor::visit (AST::Crate &crate)
      36              : {
      37        96625 :   visit_inner_attrs (crate);
      38       593465 :   for (auto &item : crate.items)
      39       496842 :     visit (item);
      40        96623 : }
      41              : 
      42              : void
      43    250315490 : DefaultASTVisitor::visit (AST::Token &tok)
      44    250315490 : {}
      45              : 
      46              : void
      47     32334102 : DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
      48              : {
      49    294247708 :   for (auto &token : delim_tok_tree.get_token_trees ())
      50    261913606 :     visit (token);
      51     32334102 : }
      52              : 
      53              : void
      54       181414 : DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
      55              : {
      56       367380 :   for (auto &item : input.get_items ())
      57       185966 :     visit (item);
      58       181414 : }
      59              : 
      60              : void
      61    214364799 : DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
      62              : {
      63    214364799 :   visit_outer_attrs (ident_expr);
      64    214364799 : }
      65              : 
      66              : void
      67     25760677 : DefaultASTVisitor::visit (AST::Lifetime &lifetime)
      68     25760677 : {}
      69              : 
      70              : void
      71      1378138 : DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
      72              : {
      73      1378138 :   visit_outer_attrs (lifetime_param);
      74      1378138 :   visit (lifetime_param.get_lifetime ());
      75      1402340 :   for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
      76        24202 :     visit (lifetime_bound);
      77      1378138 : }
      78              : 
      79              : void
      80        93660 : DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
      81              : {
      82        93660 :   visit_outer_attrs (const_param);
      83        93660 :   if (const_param.has_type ())
      84        93660 :     visit (const_param.get_type ());
      85        93660 :   if (const_param.has_default_value ())
      86          319 :     visit (const_param.get_default_value_unchecked ());
      87        93660 : }
      88              : 
      89              : void
      90     63287302 : DefaultASTVisitor::visit (AST::PathInExpression &path)
      91              : {
      92     63287302 :   visit_outer_attrs (path);
      93              : 
      94     63287302 :   if (!path.is_lang_item ())
      95    135354916 :     for (auto &segment : path.get_segments ())
      96     72307979 :       visit (segment);
      97     63287302 : }
      98              : 
      99              : void
     100    119071143 : DefaultASTVisitor::visit (AST::TypePathSegment &segment)
     101    119071143 : {}
     102              : 
     103              : void
     104       298095 : DefaultASTVisitor::visit (GenericArgsBinding &binding)
     105              : {
     106       298095 :   visit (binding.get_type ());
     107       298095 : }
     108              : 
     109              : void
     110     12227169 : DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
     111              : {
     112     12227169 :   if (segment.has_generic_args ())
     113     12227155 :     visit (segment.get_generic_args ());
     114     12227169 : }
     115              : 
     116              : void
     117       786069 : DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
     118              : {
     119      1909222 :   for (auto &input : tpf.get_params ())
     120      1123153 :     visit (input);
     121       786069 :   if (tpf.has_return_type ())
     122       759884 :     visit (tpf.get_return_type ());
     123       786069 : }
     124              : 
     125              : void
     126    160898746 : DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
     127    160898746 : {}
     128              : 
     129              : void
     130       786069 : DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
     131              : {
     132       786069 :   visit (segment.get_type_path_function ());
     133       786069 :   visit (segment.get_ident_segment ());
     134       786069 : }
     135              : 
     136              : void
     137     12528493 : DefaultASTVisitor::visit (AST::GenericArgs &args)
     138              : {
     139     13810033 :   for (auto &lifetime : args.get_lifetime_args ())
     140      1281540 :     visit (lifetime);
     141              : 
     142     24761677 :   for (auto &generic : args.get_generic_args ())
     143     12233184 :     visit (generic);
     144              : 
     145     12823720 :   for (auto &binding : args.get_binding_args ())
     146       295227 :     visit (binding);
     147     12528493 : }
     148              : 
     149              : void
     150    122523662 : DefaultASTVisitor::visit (AST::PathExprSegment &segment)
     151              : {
     152    122523662 :   visit (segment.get_ident_segment ());
     153    122523662 :   if (segment.has_generic_args ())
     154       426682 :     visit (segment.get_generic_args ());
     155    122523662 : }
     156              : void
     157     99336403 : DefaultASTVisitor::visit (AST::TypePath &path)
     158              : {
     159    205733768 :   for (auto &segment : path.get_segments ())
     160    106397365 :     visit (segment);
     161     99336403 : }
     162              : 
     163              : void
     164       180665 : DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
     165              : {
     166       180665 :   visit_outer_attrs (path);
     167       180665 :   visit (path.get_qualified_path_type ());
     168              : 
     169       361364 :   for (auto &segment : path.get_segments ())
     170       180699 :     visit (segment);
     171       180665 : }
     172              : 
     173              : void
     174      4461712 : DefaultASTVisitor::visit (AST::QualifiedPathType &path)
     175              : {
     176      4461712 :   visit (path.get_type ());
     177      4461712 :   if (path.has_as_clause ())
     178      4319325 :     visit (path.get_as_type_path ());
     179      4461712 : }
     180              : 
     181              : void
     182      5126731 : DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
     183              : {
     184      5126731 :   visit (path.get_qualified_path_type ());
     185      5126731 :   visit (path.get_associated_segment ());
     186              : 
     187      5126731 :   for (auto &segment : path.get_segments ())
     188            0 :     visit (segment);
     189      5126731 : }
     190              : 
     191              : void
     192    254324309 : DefaultASTVisitor::visit (AST::LiteralExpr &expr)
     193              : {
     194    254324309 :   visit_outer_attrs (expr);
     195    254324309 : }
     196              : 
     197              : void
     198    137890790 : DefaultASTVisitor::visit (AST::Attribute &attribute)
     199              : {
     200    137890790 :   visit (attribute.get_path ());
     201    137890790 :   if (attribute.has_attr_input ())
     202    118706401 :     visit (attribute.get_attr_input ());
     203    137890790 : }
     204              : 
     205              : void
     206     74707801 : DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
     207              : {
     208     74707801 :   visit (attr_input.get_literal ());
     209     74707801 : }
     210              : 
     211              : void
     212       183546 : DefaultASTVisitor::visit (AST::AttrInputExpr &attr_input)
     213              : {
     214       183546 :   visit (attr_input.get_expr ());
     215       183546 : }
     216              : 
     217              : void
     218            0 : DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
     219              : {
     220            0 :   visit (meta_item.get_literal ());
     221            0 : }
     222              : 
     223              : void
     224    141411801 : DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
     225    141411801 : {}
     226              : 
     227              : void
     228    140534137 : DefaultASTVisitor::visit (AST::SimplePath &path)
     229              : {
     230    281945938 :   for (auto &segment : path.get_segments ())
     231    141411801 :     visit (segment);
     232    140534137 : }
     233              : 
     234              : void
     235            1 : DefaultASTVisitor::visit (AST::MetaItemPathExpr &meta_item)
     236              : {
     237            1 :   visit (meta_item.get_path ());
     238            1 :   visit (meta_item.get_expr ());
     239            1 : }
     240              : 
     241              : void
     242      9388482 : DefaultASTVisitor::visit (AST::BorrowExpr &expr)
     243              : {
     244      9388482 :   visit_outer_attrs (expr);
     245      9388482 :   visit (expr.get_borrowed_expr ());
     246      9388482 : }
     247              : 
     248              : void
     249      4529503 : DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
     250              : {
     251      4529503 :   visit_outer_attrs (expr);
     252      4529503 :   visit (expr.get_dereferenced_expr ());
     253      4529503 : }
     254              : 
     255              : void
     256       671607 : DefaultASTVisitor::visit (AST::ErrorPropagationExpr &expr)
     257              : {
     258       671607 :   visit_outer_attrs (expr);
     259       671607 :   visit (expr.get_propagating_expr ());
     260       671607 : }
     261              : 
     262              : void
     263      1428283 : DefaultASTVisitor::visit (AST::NegationExpr &expr)
     264              : {
     265      1428283 :   visit_outer_attrs (expr);
     266      1428283 :   visit (expr.get_negated_expr ());
     267      1428283 : }
     268              : 
     269              : void
     270     35380807 : DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
     271              : {
     272     35380807 :   visit_outer_attrs (expr);
     273     35380807 :   visit (expr.get_left_expr ());
     274     35380807 :   visit (expr.get_right_expr ());
     275     35380807 : }
     276              : 
     277              : void
     278      4202831 : DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
     279              : {
     280      4202831 :   visit_outer_attrs (expr);
     281      4202831 :   visit (expr.get_left_expr ());
     282      4202831 :   visit (expr.get_right_expr ());
     283      4202831 : }
     284              : 
     285              : void
     286      1122344 : DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
     287              : {
     288      1122344 :   visit_outer_attrs (expr);
     289      1122344 :   visit (expr.get_left_expr ());
     290      1122344 :   visit (expr.get_right_expr ());
     291      1122344 : }
     292              : 
     293              : void
     294      6843186 : DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
     295              : {
     296      6843186 :   visit_outer_attrs (expr);
     297      6843186 :   visit (expr.get_casted_expr ());
     298      6843186 :   visit (expr.get_type_to_cast_to ());
     299      6843186 : }
     300              : 
     301              : void
     302      2854417 : DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
     303              : {
     304      2854417 :   visit_outer_attrs (expr);
     305      2854417 :   visit (expr.get_left_expr ());
     306      2854417 :   visit (expr.get_right_expr ());
     307      2854417 : }
     308              : 
     309              : void
     310      1805802 : DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
     311              : {
     312      1805802 :   visit_outer_attrs (expr);
     313      1805802 :   visit (expr.get_left_expr ());
     314      1805802 :   visit (expr.get_right_expr ());
     315      1805802 : }
     316              : 
     317              : void
     318      9202115 : DefaultASTVisitor::visit (AST::GroupedExpr &expr)
     319              : {
     320      9202115 :   visit_outer_attrs (expr);
     321      9202115 :   visit_inner_attrs (expr);
     322      9202115 :   visit (expr.get_expr_in_parens ());
     323      9202115 : }
     324              : 
     325              : void
     326     10400156 : DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
     327              : {
     328    109521020 :   for (auto &value : elems.get_values ())
     329     99120864 :     visit (value);
     330     10400156 : }
     331              : 
     332              : void
     333        76271 : DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
     334              : {
     335        76271 :   visit (elems.get_elem_to_copy ());
     336        76271 :   visit (elems.get_num_copies ());
     337        76271 : }
     338              : 
     339              : void
     340     20112848 : DefaultASTVisitor::visit (AST::ArrayExpr &expr)
     341              : {
     342     20112848 :   visit_outer_attrs (expr);
     343     20112848 :   visit_inner_attrs (expr);
     344     20112848 :   visit (expr.get_array_elems ());
     345     20112848 : }
     346              : 
     347              : void
     348      1297909 : DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
     349              : {
     350      1297909 :   visit_outer_attrs (expr);
     351      1297909 :   visit (expr.get_array_expr ());
     352      1297909 :   visit (expr.get_index_expr ());
     353      1297909 : }
     354              : 
     355              : void
     356      3515306 : DefaultASTVisitor::visit (AST::TupleExpr &expr)
     357              : {
     358      3515306 :   visit_outer_attrs (expr);
     359      3515306 :   visit_inner_attrs (expr);
     360     10063709 :   for (auto &elem : expr.get_tuple_elems ())
     361      6548403 :     visit (elem);
     362      3515306 : }
     363              : 
     364              : void
     365      6289893 : DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
     366              : {
     367      6289893 :   visit_outer_attrs (expr);
     368      6289893 :   visit (expr.get_tuple_expr ());
     369      6289893 : }
     370              : 
     371              : void
     372        28694 : DefaultASTVisitor::visit (AST::StructExprStruct &expr)
     373              : {
     374        28694 :   visit_outer_attrs (expr);
     375        28694 :   visit_inner_attrs (expr);
     376        28694 :   visit (expr.get_struct_name ());
     377        28694 : }
     378              : 
     379              : void
     380       360799 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
     381       360799 : {}
     382              : 
     383              : void
     384      1200898 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
     385              : {
     386      1200898 :   visit (field.get_value ());
     387      1200898 : }
     388              : 
     389              : void
     390          748 : DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
     391              : {
     392          748 :   visit (field.get_value ());
     393          748 : }
     394              : 
     395              : void
     396         6029 : DefaultASTVisitor::visit (AST::StructBase &base)
     397              : {
     398         6029 :   visit (base.get_base_struct ());
     399         6029 : }
     400              : 
     401              : void
     402       987629 : DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
     403              : {
     404       987629 :   visit_outer_attrs (expr);
     405       987629 :   visit_inner_attrs (expr);
     406       987629 :   visit (expr.get_struct_name ());
     407       987629 :   if (expr.has_struct_base ())
     408         7945 :     visit (expr.get_struct_base ());
     409      2896266 :   for (auto &field : expr.get_fields ())
     410      1908637 :     visit (field);
     411       987629 : }
     412              : 
     413              : void
     414            0 : DefaultASTVisitor::visit (AST::StructExprStructBase &expr)
     415              : {
     416            0 :   visit_outer_attrs (expr);
     417            0 :   visit_inner_attrs (expr);
     418            0 :   visit (expr.get_struct_name ());
     419            0 :   visit (expr.get_struct_base ());
     420            0 : }
     421              : 
     422              : void
     423     84137511 : DefaultASTVisitor::visit (AST::CallExpr &expr)
     424              : {
     425     84137511 :   visit_outer_attrs (expr);
     426     84137511 :   visit (expr.get_function_expr ());
     427    296667429 :   for (auto &param : expr.get_params ())
     428    212529919 :     visit (param);
     429     84137510 : }
     430              : 
     431              : void
     432     50034984 : DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
     433              : {
     434     50034984 :   visit_outer_attrs (expr);
     435     50034984 :   visit (expr.get_receiver_expr ());
     436     50034984 :   visit (expr.get_method_name ());
     437     57555136 :   for (auto &param : expr.get_params ())
     438      7520152 :     visit (param);
     439     50034984 : }
     440              : 
     441              : void
     442      7681394 : DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
     443              : {
     444      7681394 :   visit_outer_attrs (expr);
     445      7681394 :   visit (expr.get_receiver_expr ());
     446      7681394 : }
     447              : 
     448              : void
     449       457562 : DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
     450              : {
     451       457562 :   visit_outer_attrs (expr);
     452       993700 :   for (auto &param : expr.get_params ())
     453       536138 :     visit (param);
     454       457562 :   visit (expr.get_definition_expr ());
     455       457562 : }
     456              : 
     457              : void
     458     24903462 : DefaultASTVisitor::visit (AST::BlockExpr &expr)
     459              : {
     460     24903462 :   visit_outer_attrs (expr);
     461     24903462 :   visit_inner_attrs (expr);
     462              : 
     463     24903462 :   if (expr.has_label ())
     464           51 :     visit (expr.get_label ());
     465              : 
     466     38461223 :   for (auto &stmt : expr.get_statements ())
     467     13557764 :     visit (stmt);
     468              : 
     469     24903459 :   if (expr.has_tail_expr ())
     470     21421677 :     visit (expr.get_tail_expr ());
     471     24903457 : }
     472              : 
     473              : void
     474          814 : DefaultASTVisitor::visit (AST::ConstBlock &expr)
     475              : {
     476          814 :   visit (expr.get_const_expr ());
     477          814 : }
     478              : 
     479              : void
     480       448661 : DefaultASTVisitor::visit (AST::AnonConst &expr)
     481              : {
     482       448661 :   if (!expr.is_deferred ())
     483       448438 :     visit (expr.get_inner_expr ());
     484       448661 : }
     485              : 
     486              : void
     487         1202 : DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
     488              : {
     489         1202 :   visit_outer_attrs (expr);
     490         2481 :   for (auto &param : expr.get_params ())
     491         1279 :     visit (param);
     492         1202 :   visit (expr.get_return_type ());
     493         1202 :   visit (expr.get_definition_expr ());
     494         1202 : }
     495              : 
     496              : void
     497       743329 : DefaultASTVisitor::visit (AST::ClosureParam &param)
     498              : {
     499       743329 :   visit_outer_attrs (param);
     500       743329 :   visit (param.get_pattern ());
     501       743329 :   if (param.has_type_given ())
     502        35466 :     visit (param.get_type ());
     503       743329 : }
     504              : 
     505              : void
     506        12918 : DefaultASTVisitor::visit (AST::ContinueExpr &expr)
     507              : {
     508        12918 :   visit_outer_attrs (expr);
     509        12918 :   if (expr.has_label ())
     510         5469 :     visit (expr.get_label_unchecked ());
     511        12918 : }
     512              : 
     513              : void
     514       106021 : DefaultASTVisitor::visit (AST::BreakExpr &expr)
     515              : {
     516       106021 :   visit_outer_attrs (expr);
     517       106021 :   if (expr.has_label ())
     518          831 :     visit (expr.get_label_unchecked ());
     519              : 
     520       106021 :   if (expr.has_break_expr ())
     521          668 :     visit (expr.get_break_expr_unchecked ());
     522       106020 : }
     523              : 
     524              : void
     525       422277 : DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
     526              : {
     527       422277 :   visit (expr.get_from_expr ());
     528       422277 :   visit (expr.get_to_expr ());
     529       422277 : }
     530              : 
     531              : void
     532       175501 : DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
     533              : {
     534       175501 :   visit (expr.get_from_expr ());
     535       175501 : }
     536              : 
     537              : void
     538       272609 : DefaultASTVisitor::visit (AST::RangeToExpr &expr)
     539              : {
     540       272609 :   visit (expr.get_to_expr ());
     541       272609 : }
     542              : 
     543              : void
     544       120753 : DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
     545       120753 : {}
     546              : 
     547              : void
     548         9142 : DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
     549              : {
     550         9142 :   visit (expr.get_from_expr ());
     551         9142 :   visit (expr.get_to_expr ());
     552         9142 : }
     553              : 
     554              : void
     555            0 : DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
     556              : {
     557            0 :   visit (expr.get_to_expr ());
     558            0 : }
     559              : 
     560              : void
     561      1082318 : DefaultASTVisitor::visit (AST::ReturnExpr &expr)
     562              : {
     563      1082318 :   visit_outer_attrs (expr);
     564      1082318 :   if (expr.has_returned_expr ())
     565      1052646 :     visit (expr.get_returned_expr ());
     566      1082318 : }
     567              : 
     568              : void
     569        56571 : DefaultASTVisitor::visit (AST::TryExpr &expr)
     570              : {
     571        56571 :   visit_outer_attrs (expr);
     572        56571 :   visit (expr.get_block_expr ());
     573        56571 : }
     574              : 
     575              : void
     576          642 : DefaultASTVisitor::visit (AST::BoxExpr &expr)
     577              : {
     578          642 :   visit_outer_attrs (expr);
     579          642 :   visit (expr.get_boxed_expr ());
     580          642 : }
     581              : 
     582              : void
     583      1848313 : DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
     584              : {
     585      1848313 :   visit_outer_attrs (expr);
     586      1848313 :   visit (expr.get_block_expr ());
     587      1848313 : }
     588              : 
     589              : void
     590         6094 : DefaultASTVisitor::visit (AST::LoopLabel &label)
     591              : {
     592         6094 :   visit (label.get_lifetime ());
     593         6094 : }
     594              : 
     595              : void
     596        69458 : DefaultASTVisitor::visit (AST::LoopExpr &expr)
     597              : {
     598        69458 :   visit_outer_attrs (expr);
     599        69458 :   if (expr.has_loop_label ())
     600         3694 :     visit (expr.get_loop_label ());
     601        69458 :   visit (expr.get_loop_block ());
     602        69457 : }
     603              : 
     604              : void
     605       201861 : DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
     606              : {
     607       201861 :   visit_outer_attrs (expr);
     608       201861 :   if (expr.has_loop_label ())
     609          119 :     visit (expr.get_loop_label ());
     610       201861 :   visit (expr.get_predicate_expr ());
     611       201861 :   visit (expr.get_loop_block ());
     612       201861 : }
     613              : 
     614              : void
     615        43295 : DefaultASTVisitor::visit (AST::WhileLetLoopExpr &expr)
     616              : {
     617        43295 :   visit_outer_attrs (expr);
     618        43295 :   visit (expr.get_pattern ());
     619              : 
     620        43295 :   if (expr.has_loop_label ())
     621            9 :     visit (expr.get_loop_label ());
     622              : 
     623        43295 :   visit (expr.get_scrutinee_expr ());
     624        43295 :   visit (expr.get_loop_block ());
     625        43295 : }
     626              : 
     627              : void
     628       211637 : DefaultASTVisitor::visit (AST::ForLoopExpr &expr)
     629              : {
     630       211637 :   visit_outer_attrs (expr);
     631       211637 :   visit (expr.get_pattern ());
     632       211637 :   visit (expr.get_iterator_expr ());
     633       211637 :   if (expr.has_loop_label ())
     634            0 :     visit (expr.get_loop_label ());
     635       211637 :   visit (expr.get_loop_block ());
     636       211637 : }
     637              : 
     638              : void
     639      3111315 : DefaultASTVisitor::visit (AST::IfExpr &expr)
     640              : {
     641      3111315 :   visit_outer_attrs (expr);
     642      3111315 :   visit (expr.get_condition_expr ());
     643      3111315 :   visit (expr.get_if_block ());
     644      3111315 : }
     645              : 
     646              : void
     647      1982452 : DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
     648              : {
     649      1982452 :   visit (reinterpret_cast<AST::IfExpr &> (expr));
     650      1982452 :   visit (expr.get_else_block ());
     651      1982452 : }
     652              : 
     653              : void
     654       114827 : DefaultASTVisitor::visit (AST::IfLetExpr &expr)
     655              : {
     656       114827 :   visit_outer_attrs (expr);
     657       114827 :   visit (expr.get_pattern ());
     658       114827 :   visit (expr.get_value_expr ());
     659       114827 :   visit (expr.get_if_block ());
     660       114827 : }
     661              : 
     662              : void
     663        39421 : DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
     664              : {
     665        39421 :   visit (reinterpret_cast<AST::IfLetExpr &> (expr));
     666        39421 :   visit (expr.get_else_block ());
     667        39421 : }
     668              : 
     669              : void
     670     62321783 : DefaultASTVisitor::visit (AST::MatchArm &arm)
     671              : {
     672     62321783 :   visit_outer_attrs (arm);
     673     62321783 :   visit (arm.get_pattern ());
     674     62321783 :   if (arm.has_match_arm_guard ())
     675        49944 :     visit (arm.get_guard_expr ());
     676     62321783 : }
     677              : 
     678              : void
     679     62713947 : DefaultASTVisitor::visit (AST::MatchCase &arm)
     680              : {
     681     62713947 :   visit (arm.get_arm ());
     682     62713947 :   visit (arm.get_expr ());
     683     62713946 : }
     684              : 
     685              : void
     686      6172828 : DefaultASTVisitor::visit (AST::MatchExpr &expr)
     687              : {
     688      6172828 :   visit_outer_attrs (expr);
     689      6172828 :   visit_inner_attrs (expr);
     690      6172828 :   visit (expr.get_scrutinee_expr ());
     691     68886773 :   for (auto &arm : expr.get_match_cases ())
     692     62713947 :     visit (arm);
     693      6172826 : }
     694              : 
     695              : void
     696            0 : DefaultASTVisitor::visit (AST::AwaitExpr &expr)
     697              : {
     698            0 :   visit_outer_attrs (expr);
     699            0 :   visit (expr.get_awaited_expr ());
     700            0 : }
     701              : 
     702              : void
     703            0 : DefaultASTVisitor::visit (AST::AsyncBlockExpr &expr)
     704              : {
     705            0 :   visit_outer_attrs (expr);
     706            0 :   visit (expr.get_block_expr ());
     707            0 : }
     708              : 
     709              : void
     710          441 : DefaultASTVisitor::visit (AST::InlineAsm &expr)
     711              : {
     712          441 :   visit_outer_attrs (expr);
     713          441 :   using RegisterType = AST::InlineAsmOperand::RegisterType;
     714         1006 :   for (auto &operand : expr.get_operands ())
     715              :     {
     716          565 :       switch (operand.get_register_type ())
     717              :         {
     718          226 :         case RegisterType::In:
     719          226 :           {
     720          226 :             visit (operand.get_in ().expr);
     721          226 :             break;
     722              :           }
     723          313 :         case RegisterType::Out:
     724          313 :           {
     725          313 :             visit (operand.get_out ().expr);
     726          313 :             break;
     727              :           }
     728            0 :         case RegisterType::InOut:
     729            0 :           {
     730            0 :             visit (operand.get_in_out ().expr);
     731            0 :             break;
     732              :           }
     733           26 :         case RegisterType::SplitInOut:
     734           26 :           {
     735           26 :             auto split = operand.get_split_in_out ();
     736           26 :             visit (split.in_expr);
     737           26 :             visit (split.out_expr);
     738           26 :             break;
     739           26 :           }
     740            0 :         case RegisterType::Const:
     741            0 :           {
     742            0 :             visit (operand.get_const ().anon_const.get_inner_expr ());
     743            0 :             break;
     744              :           }
     745            0 :         case RegisterType::Sym:
     746            0 :           {
     747            0 :             visit (operand.get_sym ().expr);
     748            0 :             break;
     749              :           }
     750            0 :         case RegisterType::Label:
     751            0 :           {
     752            0 :             visit (operand.get_label ().expr);
     753            0 :             break;
     754              :           }
     755              :         }
     756          441 :     }
     757          441 : }
     758              : 
     759              : void
     760        17556 : DefaultASTVisitor::visit (AST::LlvmInlineAsm &expr)
     761              : {
     762        17556 :   visit_outer_attrs (expr);
     763              : 
     764        41620 :   for (auto &output : expr.get_outputs ())
     765        24064 :     visit (output.expr);
     766              : 
     767        36536 :   for (auto &input : expr.get_inputs ())
     768        18980 :     visit (input.expr);
     769        17556 : }
     770              : 
     771              : void
     772      4904614 : DefaultASTVisitor::visit (AST::TypeParam &param)
     773              : {
     774      4904614 :   visit_outer_attrs (param);
     775      6423405 :   for (auto &bound : param.get_type_param_bounds ())
     776      1518791 :     visit (bound);
     777      4904614 :   if (param.has_type ())
     778        20949 :     visit (param.get_type ());
     779      4904614 : }
     780              : 
     781              : void
     782         1782 : DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
     783              : {
     784         1782 :   visit (item.get_lifetime ());
     785         3564 :   for (auto &bound : item.get_lifetime_bounds ())
     786         1782 :     visit (bound);
     787         1782 : }
     788              : 
     789              : void
     790      1434656 : DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
     791              : {
     792      1436256 :   for (auto &lifetime : item.get_for_lifetimes ())
     793         1600 :     visit (lifetime);
     794      1434656 :   visit (item.get_type ());
     795      2936468 :   for (auto &param : item.get_type_param_bounds ())
     796      1501812 :     visit (param);
     797      1434656 : }
     798              : 
     799              : void
     800     41659400 : DefaultASTVisitor::visit (AST::Visibility &vis)
     801              : {
     802     41659400 :   if (vis.has_path ())
     803       526757 :     visit (vis.get_path ());
     804     41659400 : }
     805              : 
     806              : void
     807     21180660 : DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
     808     21180660 : {}
     809              : 
     810              : void
     811      1270237 : DefaultASTVisitor::visit (AST::WhereClause &where)
     812              : {
     813      3018125 :   for (auto &item : where.get_items ())
     814      1747888 :     visit (item);
     815      1270237 : }
     816              : void
     817     19162956 : DefaultASTVisitor::visit (AST::FunctionParam &param)
     818              : {
     819     19162956 :   visit_outer_attrs (param);
     820     19162956 :   if (param.has_name ())
     821     19162956 :     visit (param.get_pattern ());
     822              : 
     823     19162956 :   visit (param.get_type ());
     824     19162956 : }
     825              : 
     826              : void
     827     11602089 : DefaultASTVisitor::visit (AST::SelfParam &param)
     828              : {
     829     11602089 :   visit_outer_attrs (param);
     830              : 
     831     11602089 :   if (param.has_lifetime ())
     832      5308446 :     visit (param.get_lifetime ());
     833              : 
     834     11602089 :   if (param.has_type ())
     835        19866 :     visit (param.get_type ());
     836     11602089 : }
     837              : 
     838              : void
     839       239704 : DefaultASTVisitor::visit (AST::Module &module)
     840              : {
     841       239704 :   visit_outer_attrs (module);
     842       239704 :   visit (module.get_visibility ());
     843       239704 :   visit_inner_attrs (module);
     844     10049179 :   for (auto &item : module.get_items ())
     845      9809475 :     visit (item);
     846       239704 : }
     847              : 
     848              : void
     849          710 : DefaultASTVisitor::visit (AST::ExternCrate &crate)
     850              : {
     851          710 :   visit_outer_attrs (crate);
     852          710 :   visit (crate.get_visibility ());
     853          710 : }
     854              : 
     855              : void
     856        58766 : DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
     857              : {
     858        58766 :   visit (use_tree.get_path ());
     859        58766 : }
     860              : 
     861              : void
     862       186191 : DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
     863              : {
     864       186191 :   visit (use_tree.get_path ());
     865       186191 : }
     866              : 
     867              : void
     868       382567 : DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
     869              : {
     870       382567 :   visit (use_tree.get_path ());
     871       382567 : }
     872              : 
     873              : void
     874       628109 : DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
     875              : {
     876       628109 :   visit (use_decl.get_visibility ());
     877       628109 :   visit (use_decl.get_tree ());
     878       628109 : }
     879              : 
     880              : void
     881     16803218 : DefaultASTVisitor::visit_function_params (AST::Function &function)
     882              : {
     883     47505251 :   for (auto &param : function.get_function_params ())
     884     30702033 :     visit (param);
     885     16803218 : }
     886              : 
     887              : void
     888     16925781 : DefaultASTVisitor::visit (AST::Function &function)
     889              : {
     890     16925781 :   visit_outer_attrs (function);
     891     16925781 :   visit (function.get_visibility ());
     892     16925781 :   visit (function.get_qualifiers ());
     893     19043751 :   for (auto &generic : function.get_generic_params ())
     894      2117970 :     visit (generic);
     895              : 
     896     16925781 :   visit_function_params (function);
     897              : 
     898     16925781 :   if (function.has_return_type ())
     899     14656058 :     visit (function.get_return_type ());
     900     16925781 :   if (function.has_where_clause ())
     901       606940 :     visit (function.get_where_clause ());
     902     16925781 :   if (function.has_body ())
     903     15623073 :     visit (*function.get_definition ());
     904     16925779 : }
     905              : 
     906              : void
     907      3631499 : DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
     908              : {
     909      3631499 :   visit_outer_attrs (type_alias);
     910      3631499 :   visit (type_alias.get_visibility ());
     911      3631999 :   for (auto &generic : type_alias.get_generic_params ())
     912          500 :     visit (generic);
     913      3631499 :   if (type_alias.has_where_clause ())
     914            0 :     visit (type_alias.get_where_clause ());
     915      3631499 :   visit (type_alias.get_type_aliased ());
     916      3631499 : }
     917              : 
     918              : void
     919           44 : DefaultASTVisitor::visit (AST::TraitAlias &trait_alias)
     920              : {
     921           44 :   visit_outer_attrs (trait_alias);
     922           44 :   visit (trait_alias.get_visibility ());
     923           44 :   for (auto &generic : trait_alias.get_generic_params ())
     924            0 :     visit (generic);
     925           44 :   if (trait_alias.has_where_clause ())
     926            0 :     visit (trait_alias.get_where_clause ());
     927           88 :   for (auto &bound : trait_alias.get_alias_bounds ())
     928           44 :     visit (bound);
     929           44 : }
     930              : 
     931              : void
     932       553260 : DefaultASTVisitor::visit (AST::StructField &field)
     933              : {
     934       553260 :   visit_outer_attrs (field);
     935       553260 :   visit (field.get_visibility ());
     936       553260 :   visit (field.get_field_type ());
     937       553260 : }
     938              : 
     939              : void
     940      1749896 : DefaultASTVisitor::visit (AST::StructStruct &struct_item)
     941              : {
     942      1749896 :   visit_outer_attrs (struct_item);
     943      1749896 :   visit (struct_item.get_visibility ());
     944      2264914 :   for (auto &generic : struct_item.get_generic_params ())
     945       515018 :     visit (generic);
     946      1749896 :   if (struct_item.has_where_clause ())
     947        19754 :     visit (struct_item.get_where_clause ());
     948      2519434 :   for (auto &field : struct_item.get_fields ())
     949       769538 :     visit (field);
     950      1749896 : }
     951              : 
     952              : void
     953       596737 : DefaultASTVisitor::visit (AST::TupleField &field)
     954              : {
     955       596737 :   visit_outer_attrs (field);
     956       596737 :   visit (field.get_visibility ());
     957       596737 :   visit (field.get_field_type ());
     958       596737 : }
     959              : 
     960              : void
     961       199555 : DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
     962              : {
     963       199555 :   visit_outer_attrs (tuple_struct);
     964       199555 :   visit (tuple_struct.get_visibility ());
     965       282308 :   for (auto &generic : tuple_struct.get_generic_params ())
     966        82753 :     visit (generic);
     967       199555 :   if (tuple_struct.has_where_clause ())
     968         1788 :     visit (tuple_struct.get_where_clause ());
     969      1020224 :   for (auto &field : tuple_struct.get_fields ())
     970       820669 :     visit (field);
     971       199555 : }
     972              : 
     973              : void
     974       145812 : DefaultASTVisitor::visit (AST::EnumItem &item)
     975              : {
     976       145812 :   visit_outer_attrs (item);
     977       145812 :   visit (item.get_visibility ());
     978       145812 : }
     979              : 
     980              : void
     981        51661 : DefaultASTVisitor::visit (AST::EnumItemTuple &item)
     982              : {
     983        51661 :   DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
     984       112055 :   for (auto &field : item.get_tuple_fields ())
     985        60394 :     visit (field);
     986        51661 : }
     987              : 
     988              : void
     989         2093 : DefaultASTVisitor::visit (AST::EnumItemStruct &item)
     990              : {
     991         2093 :   DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
     992         5531 :   for (auto &field : item.get_struct_fields ())
     993         3438 :     visit (field);
     994         2093 : }
     995              : 
     996              : void
     997        10378 : DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
     998              : {
     999        10378 :   DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
    1000        10378 :   visit (item.get_expr ());
    1001        10378 : }
    1002              : 
    1003              : void
    1004        68446 : DefaultASTVisitor::visit (AST::Enum &enum_item)
    1005              : {
    1006        68446 :   visit_outer_attrs (enum_item);
    1007        68446 :   visit (enum_item.get_visibility ());
    1008        96596 :   for (auto &generic : enum_item.get_generic_params ())
    1009        28150 :     visit (generic);
    1010        68446 :   if (enum_item.has_where_clause ())
    1011           32 :     visit (enum_item.get_where_clause ());
    1012       259132 :   for (auto &item : enum_item.get_variants ())
    1013       190686 :     visit (item);
    1014        68446 : }
    1015              : 
    1016              : void
    1017         5941 : DefaultASTVisitor::visit (AST::Union &union_item)
    1018              : {
    1019         5941 :   visit_outer_attrs (union_item);
    1020         5941 :   visit (union_item.get_visibility ());
    1021        11143 :   for (auto &generic : union_item.get_generic_params ())
    1022         5202 :     visit (generic);
    1023         5941 :   if (union_item.has_where_clause ())
    1024            0 :     visit (union_item.get_where_clause ());
    1025        21647 :   for (auto &variant : union_item.get_variants ())
    1026        15706 :     visit (variant);
    1027         5941 : }
    1028              : 
    1029              : void
    1030       893275 : DefaultASTVisitor::visit (AST::ConstantItem &const_item)
    1031              : {
    1032       893275 :   visit_outer_attrs (const_item);
    1033       893275 :   visit (const_item.get_visibility ());
    1034       893275 :   visit (const_item.get_type ());
    1035       893275 :   if (const_item.has_expr ())
    1036       864977 :     visit (const_item.get_expr ());
    1037       893275 : }
    1038              : 
    1039              : void
    1040        42687 : DefaultASTVisitor::visit (AST::StaticItem &static_item)
    1041              : {
    1042        42687 :   visit_outer_attrs (static_item);
    1043        42687 :   visit (static_item.get_visibility ());
    1044        42687 :   visit (static_item.get_type ());
    1045        42687 :   visit (static_item.get_expr ());
    1046        42687 : }
    1047              : 
    1048              : void
    1049        98631 : DefaultASTVisitor::visit (AST::TraitItemType &item)
    1050              : {
    1051        98631 :   visit_outer_attrs (item);
    1052        99045 :   for (auto &generic : item.get_generic_params ())
    1053          414 :     visit (generic);
    1054       141013 :   for (auto &bound : item.get_type_param_bounds ())
    1055        42382 :     visit (bound);
    1056        98631 : }
    1057              : 
    1058              : void
    1059       134138 : DefaultASTVisitor::visit (AST::Trait &trait)
    1060              : {
    1061       134138 :   visit_outer_attrs (trait);
    1062       134138 :   visit (trait.get_visibility ());
    1063              : 
    1064       134138 :   visit_inner_attrs (trait);
    1065              : 
    1066       134138 :   visit (trait.get_implicit_self ());
    1067              : 
    1068       179210 :   for (auto &generic : trait.get_generic_params ())
    1069        45072 :     visit (generic);
    1070              : 
    1071       134138 :   if (trait.has_where_clause ())
    1072           91 :     visit (trait.get_where_clause ());
    1073              : 
    1074       186990 :   for (auto &bound : trait.get_type_param_bounds ())
    1075        52852 :     visit (bound);
    1076              : 
    1077       406280 :   for (auto &item : trait.get_trait_items ())
    1078       272142 :     visit (item);
    1079       134138 : }
    1080              : 
    1081              : void
    1082       187000 : DefaultASTVisitor::visit (AST::InherentImpl &impl)
    1083              : {
    1084       187000 :   visit_outer_attrs (impl);
    1085       187000 :   visit (impl.get_visibility ());
    1086              : 
    1087       353142 :   for (auto &generic : impl.get_generic_params ())
    1088       166142 :     visit (generic);
    1089       187000 :   if (impl.has_where_clause ())
    1090         1811 :     visit (impl.get_where_clause ());
    1091       187000 :   visit (impl.get_type ());
    1092       187000 :   visit_inner_attrs (impl);
    1093      1518095 :   for (auto &item : impl.get_impl_items ())
    1094      1331095 :     visit (item);
    1095       187000 : }
    1096              : 
    1097              : void
    1098      3913206 : DefaultASTVisitor::visit (AST::TraitImpl &impl)
    1099              : {
    1100      3913206 :   visit_outer_attrs (impl);
    1101      3913206 :   visit (impl.get_visibility ());
    1102              : 
    1103      7739893 :   for (auto &generic : impl.get_generic_params ())
    1104      3826687 :     visit (generic);
    1105      3913206 :   if (impl.has_where_clause ())
    1106       212089 :     visit (impl.get_where_clause ());
    1107      3913206 :   visit (impl.get_type ());
    1108      3913206 :   visit (impl.get_trait_path ());
    1109      3913206 :   visit_inner_attrs (impl);
    1110      9489269 :   for (auto &item : impl.get_impl_items ())
    1111      5576063 :     visit (item);
    1112      3913206 : }
    1113              : 
    1114              : void
    1115         1252 : DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
    1116              : {
    1117         1252 :   visit_outer_attrs (item);
    1118         1252 :   visit (item.get_visibility ());
    1119         1252 : }
    1120              : 
    1121              : void
    1122           16 : DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
    1123              : {
    1124           16 :   visit_outer_attrs (item);
    1125           16 :   visit (item.get_visibility ());
    1126           16 :   visit (item.get_type ());
    1127           16 : }
    1128              : 
    1129              : void
    1130        66220 : DefaultASTVisitor::visit (AST::ExternBlock &block)
    1131              : {
    1132        66220 :   visit_outer_attrs (block);
    1133        66220 :   visit (block.get_visibility ());
    1134        66220 :   visit_inner_attrs (block);
    1135       848232 :   for (auto &item : block.get_extern_items ())
    1136       782012 :     visit (item);
    1137        66220 : }
    1138              : 
    1139              : void
    1140      1604531 : DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
    1141      1604531 : {}
    1142              : 
    1143              : void
    1144       154847 : DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
    1145              : {
    1146       378576 :   for (auto &m : match.get_matches ())
    1147       223729 :     visit (m);
    1148       154847 : }
    1149              : 
    1150              : void
    1151       735795 : DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
    1152              : {
    1153      3358840 :   for (auto &m : matcher.get_matches ())
    1154      2623045 :     visit (m);
    1155       735795 : }
    1156              : 
    1157              : void
    1158       699043 : DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
    1159              : {
    1160       699043 :   visit (transcriber.get_token_tree ());
    1161       699043 : }
    1162              : 
    1163              : void
    1164       699043 : DefaultASTVisitor::visit (AST::MacroRule &rule)
    1165              : {
    1166       699043 :   visit (rule.get_matcher ());
    1167       699043 :   visit (rule.get_transcriber ());
    1168       699043 : }
    1169              : void
    1170       658796 : DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
    1171              : {
    1172       658796 :   visit_outer_attrs (rules_def);
    1173      1357839 :   for (auto &rule : rules_def.get_macro_rules ())
    1174       699043 :     visit (rule);
    1175       658796 : }
    1176              : 
    1177              : void
    1178      1351161 : DefaultASTVisitor::visit (AST::MacroInvocData &data)
    1179              : {
    1180      1351161 :   visit (data.get_path ());
    1181      1351161 :   visit (data.get_delim_tok_tree ());
    1182      1351161 : }
    1183              : void
    1184      1351161 : DefaultASTVisitor::visit (AST::MacroInvocation &macro_invoc)
    1185              : {
    1186      1351161 :   visit_outer_attrs (macro_invoc);
    1187      1351161 :   visit (macro_invoc.get_invoc_data ());
    1188      1351161 : }
    1189              : 
    1190              : void
    1191        13284 : DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
    1192              : {
    1193        13284 :   visit (meta_item.get_path ());
    1194        13284 : }
    1195              : 
    1196              : void
    1197       124620 : DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
    1198              : {
    1199       124620 :   visit (meta_item.get_path ());
    1200       285745 :   for (auto &inner : meta_item.get_seq ())
    1201       161125 :     visit (inner);
    1202       124620 : }
    1203              : 
    1204              : void
    1205        84313 : DefaultASTVisitor::visit (AST::MetaWord &meta_item)
    1206        84313 : {}
    1207              : 
    1208              : void
    1209       170403 : DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
    1210       170403 : {}
    1211              : 
    1212              : void
    1213            0 : DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
    1214              : {
    1215            0 :   for (auto &path : meta_item.get_paths ())
    1216            0 :     visit (path);
    1217            0 : }
    1218              : 
    1219              : void
    1220            0 : DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
    1221              : {
    1222            0 :   for (auto &str : meta_item.get_values ())
    1223            0 :     visit (str);
    1224            0 : }
    1225              : 
    1226              : void
    1227     83695117 : DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
    1228     83695117 : {}
    1229              : 
    1230              : void
    1231     12405192 : DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
    1232              : {
    1233     12405192 :   if (pattern.has_subpattern ())
    1234        19049 :     visit (pattern.get_subpattern ());
    1235     12405192 : }
    1236              : 
    1237              : void
    1238      8119743 : DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
    1239      8119743 : {}
    1240              : 
    1241              : void
    1242        21901 : DefaultASTVisitor::visit (AST::RestPattern &pattern)
    1243        21901 : {}
    1244              : 
    1245              : void
    1246       361811 : DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
    1247       361811 : {}
    1248              : 
    1249              : void
    1250          405 : DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
    1251              : {
    1252          405 :   visit (bound.get_path ());
    1253          405 : }
    1254              : 
    1255              : void
    1256            0 : DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
    1257              : {
    1258            0 :   visit (bound.get_qualified_path ());
    1259            0 : }
    1260              : 
    1261              : void
    1262       139993 : DefaultASTVisitor::visit (AST::RangePattern &pattern)
    1263              : {
    1264       139993 :   if (pattern.get_has_lower_bound ())
    1265       139993 :     visit (pattern.get_lower_bound ());
    1266       139993 :   if (pattern.get_has_upper_bound ())
    1267       139993 :     visit (pattern.get_upper_bound ());
    1268       139993 : }
    1269              : 
    1270              : void
    1271       343814 : DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
    1272              : {
    1273       343814 :   visit (pattern.get_referenced_pattern ());
    1274       343814 : }
    1275              : 
    1276              : void
    1277          597 : DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
    1278              : {
    1279          597 :   visit_outer_attrs (field);
    1280          597 :   visit (field.get_index_pattern ());
    1281          597 : }
    1282              : 
    1283              : void
    1284        61489 : DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
    1285              : {
    1286        61489 :   visit_outer_attrs (field);
    1287        61489 :   visit (field.get_ident_pattern ());
    1288        61489 : }
    1289              : 
    1290              : void
    1291        17020 : DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
    1292              : {
    1293        17020 :   visit_outer_attrs (field);
    1294        17020 : }
    1295              : 
    1296              : void
    1297        63621 : DefaultASTVisitor::visit (AST::StructPatternElements &spe)
    1298              : {
    1299       146394 :   for (auto &field : spe.get_struct_pattern_fields ())
    1300        82773 :     visit (field);
    1301        63621 :   for (auto &attribute : spe.get_etc_outer_attrs ())
    1302            0 :     visit (attribute);
    1303        63621 : }
    1304              : 
    1305              : void
    1306        63621 : DefaultASTVisitor::visit (AST::StructPattern &pattern)
    1307              : {
    1308        63621 :   visit (pattern.get_path ());
    1309        63621 :   visit (pattern.get_struct_pattern_elems ());
    1310        63621 : }
    1311              : 
    1312              : void
    1313      1357840 : DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
    1314              : {
    1315      2757303 :   for (auto &pattern : tuple_items.get_patterns ())
    1316      1399463 :     visit (pattern);
    1317      1357840 : }
    1318              : 
    1319              : void
    1320        13423 : DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
    1321              : {
    1322        14417 :   for (auto &lower : tuple_items.get_lower_patterns ())
    1323          994 :     visit (lower);
    1324        14174 :   for (auto &upper : tuple_items.get_upper_patterns ())
    1325          751 :     visit (upper);
    1326        13423 : }
    1327              : 
    1328              : void
    1329      1803805 : DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
    1330              : {
    1331      1803805 :   visit (pattern.get_path ());
    1332      1803805 :   visit (pattern.get_items ());
    1333      1803805 : }
    1334              : 
    1335              : void
    1336      3897272 : DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
    1337              : {
    1338     12828974 :   for (auto &pattern : tuple_items.get_patterns ())
    1339      8931702 :     visit (pattern);
    1340      3897272 : }
    1341              : 
    1342              : void
    1343          643 : DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
    1344              : {
    1345         1196 :   for (auto &lower : tuple_items.get_lower_patterns ())
    1346          553 :     visit (lower);
    1347         1241 :   for (auto &upper : tuple_items.get_upper_patterns ())
    1348          598 :     visit (upper);
    1349          643 : }
    1350              : 
    1351              : void
    1352      5281753 : DefaultASTVisitor::visit (AST::TuplePattern &pattern)
    1353              : {
    1354      5281753 :   visit (pattern.get_items ());
    1355      5281753 : }
    1356              : 
    1357              : void
    1358          899 : DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
    1359              : {
    1360          899 :   visit (pattern.get_pattern_in_parens ());
    1361          899 : }
    1362              : 
    1363              : void
    1364        24772 : DefaultASTVisitor::visit (AST::SlicePattern &pattern)
    1365              : {
    1366        73779 :   for (auto &pat : pattern.get_patterns ())
    1367        49007 :     visit (pat);
    1368        24772 : }
    1369              : 
    1370              : void
    1371        58550 : DefaultASTVisitor::visit (AST::AltPattern &pattern)
    1372              : {
    1373       214646 :   for (auto &alt : pattern.get_alts ())
    1374       156096 :     visit (alt);
    1375        58550 : }
    1376              : 
    1377              : void
    1378         1474 : DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
    1379         1474 : {}
    1380              : 
    1381              : void
    1382      6920470 : DefaultASTVisitor::visit (AST::LetStmt &stmt)
    1383              : {
    1384      6920470 :   visit_outer_attrs (stmt);
    1385      6920470 :   visit (stmt.get_pattern ());
    1386      6920470 :   if (stmt.has_type ())
    1387       749120 :     visit (stmt.get_type ());
    1388      6920470 :   if (stmt.has_init_expr ())
    1389      6701720 :     visit (stmt.get_init_expr ());
    1390      6920470 : }
    1391              : 
    1392              : void
    1393      9942304 : DefaultASTVisitor::visit (AST::ExprStmt &stmt)
    1394              : {
    1395      9942304 :   visit (stmt.get_expr ());
    1396      9942302 : }
    1397              : 
    1398              : void
    1399      5269025 : DefaultASTVisitor::visit (AST::TraitBound &bound)
    1400              : {
    1401      5270622 :   for (auto &lifetime : bound.get_for_lifetimes ())
    1402         1597 :     visit (lifetime);
    1403      5269025 :   visit (bound.get_type_path ());
    1404      5269025 : }
    1405              : 
    1406              : void
    1407       142320 : DefaultASTVisitor::visit (AST::ImplTraitType &type)
    1408              : {
    1409       289870 :   for (auto &bound : type.get_type_param_bounds ())
    1410       147550 :     visit (bound);
    1411       142320 : }
    1412              : 
    1413              : void
    1414       101141 : DefaultASTVisitor::visit (AST::TraitObjectType &type)
    1415              : {
    1416       307096 :   for (auto &bound : type.get_type_param_bounds ())
    1417       205955 :     visit (bound);
    1418       101141 : }
    1419              : 
    1420              : void
    1421        13855 : DefaultASTVisitor::visit (AST::ParenthesisedType &type)
    1422              : {
    1423        13855 :   visit (type.get_type_in_parens ());
    1424        13855 : }
    1425              : 
    1426              : void
    1427       267842 : DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
    1428              : {
    1429       267842 :   visit (type.get_trait_bound ());
    1430       267842 : }
    1431              : 
    1432              : void
    1433        45076 : DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
    1434              : {
    1435        45076 :   visit (type.get_trait_bound ());
    1436        45076 : }
    1437              : 
    1438              : void
    1439      1453786 : DefaultASTVisitor::visit (AST::TupleType &type)
    1440              : {
    1441      4737173 :   for (auto &elem : type.get_elems ())
    1442      3283387 :     visit (elem);
    1443      1453786 : }
    1444              : 
    1445              : void
    1446       104430 : DefaultASTVisitor::visit (AST::NeverType &type)
    1447       104430 : {}
    1448              : 
    1449              : void
    1450      2165203 : DefaultASTVisitor::visit (AST::RawPointerType &type)
    1451              : {
    1452      2165203 :   visit (type.get_type_pointed_to ());
    1453      2165203 : }
    1454              : 
    1455              : void
    1456     12307290 : DefaultASTVisitor::visit (AST::ReferenceType &type)
    1457              : {
    1458     12307290 :   visit (type.get_lifetime ());
    1459     12307290 :   visit (type.get_base_type ());
    1460     12307290 : }
    1461              : 
    1462              : void
    1463       448033 : DefaultASTVisitor::visit (AST::ArrayType &type)
    1464              : {
    1465       448033 :   visit (type.get_elem_type ());
    1466       448033 :   visit (type.get_size_expr ());
    1467       448033 : }
    1468              : 
    1469              : void
    1470       942985 : DefaultASTVisitor::visit (AST::SliceType &type)
    1471              : {
    1472       942985 :   visit (type.get_elem_type ());
    1473       942985 : }
    1474              : 
    1475              : void
    1476       442527 : DefaultASTVisitor::visit (AST::InferredType &type)
    1477       442527 : {}
    1478              : 
    1479              : void
    1480      3673199 : DefaultASTVisitor::visit (AST::MaybeNamedParam &param)
    1481              : {
    1482      3673199 :   visit_outer_attrs (param);
    1483      3673199 :   visit (param.get_type ());
    1484      3673199 : }
    1485              : 
    1486              : void
    1487       617115 : DefaultASTVisitor::visit (AST::BareFunctionType &type)
    1488              : {
    1489       617180 :   for (auto &lifetime : type.get_for_lifetimes ())
    1490           65 :     visit (lifetime);
    1491       617115 :   visit (type.get_function_qualifiers ());
    1492      4290314 :   for (auto &param : type.get_function_params ())
    1493      3673199 :     visit (param);
    1494       617115 :   if (type.is_variadic ())
    1495       186816 :     for (auto attr : type.get_variadic_attr ())
    1496            0 :       visit (attr);
    1497       617115 :   if (type.has_return_type ())
    1498       603282 :     visit (type.get_return_type ());
    1499       617115 : }
    1500              : 
    1501              : void
    1502            0 : DefaultASTVisitor::visit (AST::FormatArgs &)
    1503              : {
    1504              :   // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
    1505            0 : }
    1506              : 
    1507              : void
    1508          170 : DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
    1509              : {
    1510          170 :   visit (offset_of.get_type ());
    1511          170 : }
    1512              : 
    1513              : void
    1514        14909 : DefaultASTVisitor::visit (AST::VariadicParam &param)
    1515              : {
    1516        14909 :   if (param.has_pattern ())
    1517          176 :     visit (param.get_pattern ());
    1518        14909 : }
    1519              : 
    1520              : void
    1521         5264 : ContextualASTVisitor::visit (AST::Crate &crate)
    1522              : {
    1523         5264 :   ctx.enter (Kind::CRATE);
    1524         5264 :   DefaultASTVisitor::visit (crate);
    1525         5264 :   ctx.exit ();
    1526         5264 : }
    1527              : 
    1528              : void
    1529         3577 : ContextualASTVisitor::visit (AST::InherentImpl &impl)
    1530              : {
    1531         3577 :   ctx.enter (Kind::INHERENT_IMPL);
    1532         3577 :   DefaultASTVisitor::visit (impl);
    1533         3577 :   ctx.exit ();
    1534         3577 : }
    1535              : 
    1536              : void
    1537        62003 : ContextualASTVisitor::visit (AST::TraitImpl &impl)
    1538              : {
    1539        62003 :   ctx.enter (Kind::TRAIT_IMPL);
    1540        62003 :   DefaultASTVisitor::visit (impl);
    1541        62003 :   ctx.exit ();
    1542        62003 : }
    1543              : 
    1544              : void
    1545         5746 : ContextualASTVisitor::visit (AST::Trait &trait)
    1546              : {
    1547         5746 :   ctx.enter (Kind::TRAIT);
    1548         5746 :   DefaultASTVisitor::visit (trait);
    1549         5746 :   ctx.exit ();
    1550         5746 : }
    1551              : 
    1552              : void
    1553       122595 : ContextualASTVisitor::visit (AST::Function &function)
    1554              : {
    1555       122595 :   ctx.enter (Kind::FUNCTION);
    1556       122595 :   DefaultASTVisitor::visit (function);
    1557       122595 :   ctx.exit ();
    1558       122595 : }
    1559              : 
    1560              : } // namespace AST
    1561              : } // namespace Rust
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.