LCOV - code coverage report
Current view: top level - gcc/rust/ast - rust-ast-pointer-visitor.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.2 % 623 587
Test Date: 2026-11-14 16:39:50 Functions: 95.6 % 113 108
Legend: Lines:     hit not hit

            Line data    Source code
       1              : // Copyright (C) 2025-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-pointer-visitor.h"
      20              : #include "rust-ast-visitor.h"
      21              : #include "rust-ast-full.h"
      22              : 
      23              : namespace Rust {
      24              : namespace AST {
      25              : 
      26              : void
      27        17507 : PointerVisitor::visit (AST::Crate &crate)
      28              : {
      29        17507 :   visit_inner_attrs (crate);
      30       112509 :   for (auto &item : crate.items)
      31        95002 :     reseat (item);
      32        17507 : }
      33              : 
      34              : void
      35        41122 : PointerVisitor::visit (AST::AttrInputMetaItemContainer &input)
      36              : {
      37              :   // FIXME: I think we might actually have to reseat sub-items for macro
      38              :   // invocations within attributes correct?
      39              : 
      40        86732 :   for (auto &item : input.get_items ())
      41        45610 :     visit (item);
      42        41122 : }
      43              : 
      44              : void
      45     32831760 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
      46              : {
      47     32831760 :   visit_outer_attrs (ident_expr);
      48     32831760 : }
      49              : 
      50              : void
      51       330711 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
      52              : {
      53       330711 :   visit_outer_attrs (lifetime_param);
      54              : 
      55              :   // Nothing to do for lifetimes right?
      56       330711 : }
      57              : 
      58              : void
      59        21997 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
      60              : {
      61        21997 :   visit_outer_attrs (const_param);
      62        21997 :   if (const_param.has_type ())
      63        21997 :     reseat (const_param.get_type_ptr ());
      64              : 
      65        21997 :   if (const_param.has_default_value ())
      66           60 :     visit (const_param.get_default_value_unchecked ());
      67        21997 : }
      68              : 
      69              : void
      70     20241727 : PointerVisitor::visit (AST::PathInExpression &path)
      71              : {
      72     20241727 :   visit_outer_attrs (path);
      73              : 
      74     20241727 :   if (!path.is_lang_item ())
      75     43315934 :     for (auto &segment : path.get_segments ())
      76     23136625 :       visit (segment);
      77     20241727 : }
      78              : 
      79              : void
      80        95505 : PointerVisitor::visit (GenericArgsBinding &binding)
      81              : {
      82        95505 :   reseat (binding.get_type_ptr ());
      83        95505 : }
      84              : 
      85              : void
      86      3910671 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
      87              : {
      88      3910671 :   if (segment.has_generic_args ())
      89      3910668 :     visit (segment.get_generic_args ());
      90      3910671 : }
      91              : 
      92              : void
      93       145418 : PointerVisitor::visit (AST::TypePathFunction &tpf)
      94              : {
      95       347599 :   for (auto &input : tpf.get_params ())
      96       202181 :     reseat (input);
      97       145418 :   if (tpf.has_return_type ())
      98       140517 :     reseat (tpf.get_return_type_ptr ());
      99       145418 : }
     100              : 
     101              : void
     102       145418 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
     103              : {
     104              :   // FIXME: No reseating here correct? No macros possible or desugar?
     105       145418 :   visit (segment.get_type_path_function ());
     106       145418 :   visit (segment.get_ident_segment ());
     107       145418 : }
     108              : 
     109              : void
     110      4046055 : PointerVisitor::visit (AST::GenericArgs &args)
     111              : {
     112              :   // Nothing to do for lifetimes?
     113              :   // for (auto &lifetime : args.get_lifetime_args ())
     114              :   //   reseat (lifetime);
     115              : 
     116              :   // FIXME: Actually this can probably be a macro invocation, so we need to
     117              :   // reseat them?
     118      7997106 :   for (auto &generic : args.get_generic_args ())
     119      3951051 :     visit (generic);
     120              : 
     121      4141560 :   for (auto &binding : args.get_binding_args ())
     122        95505 :     visit (binding);
     123      4046055 : }
     124              : 
     125              : void
     126     37443597 : PointerVisitor::visit (AST::PathExprSegment &segment)
     127              : {
     128     37443597 :   visit (segment.get_ident_segment ());
     129     37443597 :   if (segment.has_generic_args ())
     130       135387 :     visit (segment.get_generic_args ());
     131     37443597 : }
     132              : void
     133     36023319 : PointerVisitor::visit (AST::TypePath &path)
     134              : {
     135     74637942 :   for (auto &segment : path.get_segments ())
     136     38614623 :     visit (segment);
     137     36023319 : }
     138              : 
     139              : void
     140        28187 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
     141              : {
     142        28187 :   visit_outer_attrs (path);
     143        28187 :   visit (path.get_qualified_path_type ());
     144              : 
     145        56379 :   for (auto &segment : path.get_segments ())
     146        28192 :     visit (segment);
     147        28187 : }
     148              : 
     149              : void
     150       873871 : PointerVisitor::visit (AST::QualifiedPathType &path)
     151              : {
     152       873871 :   reseat (path.get_type_ptr ());
     153       873871 :   if (path.has_as_clause ())
     154       852793 :     visit (path.get_as_type_path ());
     155       873871 : }
     156              : 
     157              : void
     158            0 : PointerVisitor::visit (AST::MetaItemPathExpr &meta_item)
     159              : {
     160            0 :   visit (meta_item.get_path ());
     161            0 :   reseat (meta_item.get_expr_ptr ());
     162            0 : }
     163              : 
     164              : void
     165      1597634 : PointerVisitor::visit (AST::BorrowExpr &expr)
     166              : {
     167      1597634 :   visit_outer_attrs (expr);
     168      1597634 :   reseat (expr.get_borrowed_expr_ptr ());
     169      1597634 : }
     170              : 
     171              : void
     172      2844764 : PointerVisitor::visit (AST::DereferenceExpr &expr)
     173              : {
     174      2844764 :   visit_outer_attrs (expr);
     175      2844764 :   reseat (expr.get_dereferenced_expr_ptr ());
     176      2844764 : }
     177              : 
     178              : void
     179       108204 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
     180              : {
     181       108204 :   visit_outer_attrs (expr);
     182       108204 :   reseat (expr.get_propagating_expr_ptr ());
     183       108204 : }
     184              : 
     185              : void
     186       481296 : PointerVisitor::visit (AST::NegationExpr &expr)
     187              : {
     188       481296 :   visit_outer_attrs (expr);
     189       481296 :   reseat (expr.get_negated_expr_ptr ());
     190       481296 : }
     191              : 
     192              : void
     193     11819514 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
     194              : {
     195     11819514 :   visit_outer_attrs (expr);
     196     11819514 :   reseat (expr.get_left_expr_ptr ());
     197     11819514 :   reseat (expr.get_right_expr_ptr ());
     198     11819514 : }
     199              : 
     200              : void
     201      1407472 : PointerVisitor::visit (AST::ComparisonExpr &expr)
     202              : {
     203      1407472 :   visit_outer_attrs (expr);
     204      1407472 :   reseat (expr.get_left_expr_ptr ());
     205      1407472 :   reseat (expr.get_right_expr_ptr ());
     206      1407472 : }
     207              : 
     208              : void
     209       400718 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
     210              : {
     211       400718 :   visit_outer_attrs (expr);
     212       400718 :   reseat (expr.get_left_expr_ptr ());
     213       400718 :   reseat (expr.get_right_expr_ptr ());
     214       400718 : }
     215              : 
     216              : void
     217      1919676 : PointerVisitor::visit (AST::TypeCastExpr &expr)
     218              : {
     219      1919676 :   visit_outer_attrs (expr);
     220      1919676 :   reseat (expr.get_casted_expr_ptr ());
     221      1919676 :   reseat (expr.get_type_to_cast_to_ptr ());
     222      1919676 : }
     223              : 
     224              : void
     225       582311 : PointerVisitor::visit (AST::AssignmentExpr &expr)
     226              : {
     227       582311 :   visit_outer_attrs (expr);
     228       582311 :   reseat (expr.get_left_expr_ptr ());
     229       582311 :   reseat (expr.get_right_expr_ptr ());
     230       582311 : }
     231              : 
     232              : void
     233       454453 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
     234              : {
     235       454453 :   visit_outer_attrs (expr);
     236       454453 :   reseat (expr.get_left_expr_ptr ());
     237       454453 :   reseat (expr.get_right_expr_ptr ());
     238       454453 : }
     239              : 
     240              : void
     241      3433498 : PointerVisitor::visit (AST::GroupedExpr &expr)
     242              : {
     243      3433498 :   visit_outer_attrs (expr);
     244      3433498 :   visit_inner_attrs (expr);
     245      3433498 :   reseat (expr.get_expr_in_parens_ptr ());
     246      3433498 : }
     247              : 
     248              : void
     249      6575406 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
     250              : {
     251     69136931 :   for (auto &value : elems.get_values ())
     252     62561525 :     reseat (value);
     253      6575406 : }
     254              : 
     255              : void
     256        22119 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
     257              : {
     258        22119 :   reseat (elems.get_elem_to_copy_ptr ());
     259        22119 :   reseat (elems.get_num_copies_ptr ());
     260        22119 : }
     261              : 
     262              : void
     263      6597525 : PointerVisitor::visit (AST::ArrayExpr &expr)
     264              : {
     265      6597525 :   visit_outer_attrs (expr);
     266      6597525 :   visit_inner_attrs (expr);
     267      6597525 :   visit (expr.get_array_elems ());
     268      6597525 : }
     269              : 
     270              : void
     271       252261 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
     272              : {
     273       252261 :   visit_outer_attrs (expr);
     274       252261 :   reseat (expr.get_array_expr_ptr ());
     275       252261 :   reseat (expr.get_index_expr_ptr ());
     276       252261 : }
     277              : 
     278              : void
     279      2241693 : PointerVisitor::visit (AST::TupleExpr &expr)
     280              : {
     281      2241693 :   visit_outer_attrs (expr);
     282      2241693 :   visit_inner_attrs (expr);
     283      6418308 :   for (auto &elem : expr.get_tuple_elems ())
     284      4176615 :     reseat (elem);
     285      2241693 : }
     286              : 
     287              : void
     288      1914450 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
     289              : {
     290      1914450 :   visit_outer_attrs (expr);
     291      1914450 :   reseat (expr.get_tuple_expr_ptr ());
     292      1914450 : }
     293              : 
     294              : void
     295       353461 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
     296              : {
     297       353461 :   reseat (field.get_value_ptr ());
     298       353461 : }
     299              : 
     300              : void
     301          220 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
     302              : {
     303          220 :   reseat (field.get_value_ptr ());
     304          220 : }
     305              : 
     306              : void
     307         2005 : PointerVisitor::visit (AST::StructBase &base)
     308              : {
     309         2005 :   reseat (base.get_base_struct_ptr ());
     310         2005 : }
     311              : 
     312              : void
     313     32489331 : PointerVisitor::visit (AST::CallExpr &expr)
     314              : {
     315     32489331 :   visit_outer_attrs (expr);
     316     32489331 :   reseat (expr.get_function_expr_ptr ());
     317    118370211 :   for (auto &param : expr.get_params ())
     318     85880880 :     reseat (param);
     319     32489331 : }
     320              : 
     321              : void
     322     14278780 : PointerVisitor::visit (AST::MethodCallExpr &expr)
     323              : {
     324     14278780 :   visit_outer_attrs (expr);
     325     14278780 :   reseat (expr.get_receiver_expr_ptr ());
     326     14278780 :   visit (expr.get_method_name ());
     327     16469946 :   for (auto &param : expr.get_params ())
     328      2191166 :     reseat (param);
     329     14278780 : }
     330              : 
     331              : void
     332      1751861 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
     333              : {
     334      1751861 :   visit_outer_attrs (expr);
     335      1751861 :   reseat (expr.get_receiver_expr_ptr ());
     336      1751861 : }
     337              : 
     338              : void
     339        85596 : PointerVisitor::visit (AST::ClosureExprInner &expr)
     340              : {
     341        85596 :   visit_outer_attrs (expr);
     342              : 
     343              :   // TODO: Actually we need to handle macro invocations as closure parameters so
     344              :   // this needs to be a reseat
     345       188153 :   for (auto &param : expr.get_params ())
     346       102557 :     visit (param);
     347              : 
     348        85596 :   reseat (expr.get_definition_expr_ptr ());
     349        85596 : }
     350              : 
     351              : void
     352      4690019 : PointerVisitor::visit (AST::BlockExpr &expr)
     353              : {
     354      4690019 :   visit_outer_attrs (expr);
     355      4690019 :   visit_inner_attrs (expr);
     356              : 
     357      4690019 :   if (expr.has_label ())
     358            9 :     visit (expr.get_label ());
     359              : 
     360      7197833 :   for (auto &stmt : expr.get_statements ())
     361      2507814 :     reseat (stmt);
     362              : 
     363      4690019 :   if (expr.has_tail_expr ())
     364      4132862 :     reseat (expr.get_tail_expr_ptr ());
     365      4690019 : }
     366              : 
     367              : void
     368       163986 : PointerVisitor::visit (AST::AnonConst &expr)
     369              : {
     370       163986 :   if (!expr.is_deferred ())
     371       163935 :     reseat (expr.get_inner_expr_ptr ());
     372       163986 : }
     373              : 
     374              : void
     375          378 : PointerVisitor::visit (AST::ClosureExprInnerTyped &expr)
     376              : {
     377          378 :   visit_outer_attrs (expr);
     378              : 
     379              :   // TODO: Same as ClosureExprInner
     380          777 :   for (auto &param : expr.get_params ())
     381          399 :     visit (param);
     382              : 
     383          378 :   reseat (expr.get_return_type_ptr ());
     384              : 
     385          378 :   reseat (expr.get_definition_expr_ptr ());
     386          378 : }
     387              : 
     388              : void
     389       102956 : PointerVisitor::visit (AST::ClosureParam &param)
     390              : {
     391       102956 :   visit_outer_attrs (param);
     392       102956 :   reseat (param.get_pattern_ptr ());
     393       102956 :   if (param.has_type_given ())
     394         5098 :     reseat (param.get_type_ptr ());
     395       102956 : }
     396              : 
     397              : void
     398         8083 : PointerVisitor::visit (AST::ContinueExpr &expr)
     399              : {
     400         8083 :   visit_outer_attrs (expr);
     401         8083 :   if (expr.has_label ())
     402         3443 :     visit (expr.get_label_unchecked ());
     403         8083 : }
     404              : 
     405              : void
     406        17854 : PointerVisitor::visit (AST::BreakExpr &expr)
     407              : {
     408        17854 :   visit_outer_attrs (expr);
     409        17854 :   if (expr.has_label ())
     410          190 :     visit (expr.get_label_unchecked ());
     411              : 
     412        17854 :   if (expr.has_break_expr ())
     413          140 :     reseat (expr.get_break_expr_ptr_unchecked ());
     414        17854 : }
     415              : 
     416              : void
     417        69110 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
     418              : {
     419        69110 :   reseat (expr.get_from_expr_ptr ());
     420        69110 :   reseat (expr.get_to_expr_ptr ());
     421        69110 : }
     422              : 
     423              : void
     424        31776 : PointerVisitor::visit (AST::RangeFromExpr &expr)
     425              : {
     426        31776 :   reseat (expr.get_from_expr_ptr ());
     427        31776 : }
     428              : 
     429              : void
     430        62785 : PointerVisitor::visit (AST::RangeToExpr &expr)
     431              : {
     432        62785 :   reseat (expr.get_to_expr_ptr ());
     433        62785 : }
     434              : 
     435              : void
     436         3488 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
     437              : {
     438         3488 :   reseat (expr.get_from_expr_ptr ());
     439         3488 :   reseat (expr.get_to_expr_ptr ());
     440         3488 : }
     441              : 
     442              : void
     443            0 : PointerVisitor::visit (AST::RangeToInclExpr &expr)
     444              : {
     445            0 :   reseat (expr.get_to_expr_ptr ());
     446            0 : }
     447              : 
     448              : void
     449       207805 : PointerVisitor::visit (AST::ReturnExpr &expr)
     450              : {
     451       207805 :   visit_outer_attrs (expr);
     452       207805 :   if (expr.has_returned_expr ())
     453       200051 :     reseat (expr.get_returned_expr_ptr ());
     454       207805 : }
     455              : 
     456              : void
     457        16804 : PointerVisitor::visit (AST::TryExpr &expr)
     458              : {
     459        16804 :   visit_outer_attrs (expr);
     460        16804 :   reseat (expr.get_block_expr_ptr ());
     461        16804 : }
     462              : 
     463              : void
     464          143 : PointerVisitor::visit (AST::BoxExpr &expr)
     465              : {
     466          143 :   visit_outer_attrs (expr);
     467          143 :   reseat (expr.get_boxed_expr_ptr ());
     468          143 : }
     469              : 
     470              : void
     471       599904 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
     472              : {
     473       599904 :   visit_outer_attrs (expr);
     474       599904 :   reseat (expr.get_block_expr_ptr ());
     475       599904 : }
     476              : 
     477              : void
     478        24318 : PointerVisitor::visit (AST::LoopExpr &expr)
     479              : {
     480        24318 :   visit_outer_attrs (expr);
     481        24318 :   if (expr.has_loop_label ())
     482         1376 :     visit (expr.get_loop_label ());
     483        24318 :   reseat (expr.get_loop_block_ptr ());
     484        24318 : }
     485              : 
     486              : void
     487        56999 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
     488              : {
     489        56999 :   visit_outer_attrs (expr);
     490        56999 :   if (expr.has_loop_label ())
     491           35 :     visit (expr.get_loop_label ());
     492        56999 :   reseat (expr.get_predicate_expr_ptr ());
     493        56999 :   reseat (expr.get_loop_block_ptr ());
     494        56999 : }
     495              : 
     496              : void
     497        12836 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
     498              : {
     499        12836 :   visit_outer_attrs (expr);
     500        12836 :   reseat (expr.get_pattern ());
     501              : 
     502        12836 :   if (expr.has_loop_label ())
     503            4 :     visit (expr.get_loop_label ());
     504              : 
     505        12836 :   reseat (expr.get_scrutinee_expr_ptr ());
     506        12836 :   reseat (expr.get_loop_block_ptr ());
     507        12836 : }
     508              : 
     509              : void
     510        57120 : PointerVisitor::visit (AST::ForLoopExpr &expr)
     511              : {
     512        57120 :   visit_outer_attrs (expr);
     513        57120 :   reseat (expr.get_pattern_ptr ());
     514        57120 :   reseat (expr.get_iterator_expr_ptr ());
     515        57120 :   if (expr.has_loop_label ())
     516            0 :     visit (expr.get_loop_label ());
     517        57120 :   reseat (expr.get_loop_block_ptr ());
     518        57120 : }
     519              : 
     520              : void
     521       491537 : PointerVisitor::visit (AST::IfExpr &expr)
     522              : {
     523       491537 :   visit_outer_attrs (expr);
     524       491537 :   reseat (expr.get_condition_expr_ptr ());
     525       491537 :   visit (expr.get_if_block ());
     526       491537 : }
     527              : 
     528              : void
     529        26492 : PointerVisitor::visit (AST::IfLetExpr &expr)
     530              : {
     531        26492 :   visit_outer_attrs (expr);
     532        26492 :   reseat (expr.get_pattern ());
     533        26492 :   reseat (expr.get_value_expr_ptr ());
     534        26492 :   visit (expr.get_if_block ());
     535        26492 : }
     536              : 
     537              : void
     538     25999626 : PointerVisitor::visit (AST::MatchArm &arm)
     539              : {
     540     25999626 :   visit_outer_attrs (arm);
     541     25999626 :   reseat (arm.get_pattern ());
     542     25999626 :   if (arm.has_match_arm_guard ())
     543        18735 :     reseat (arm.get_guard_expr_ptr ());
     544     25999626 : }
     545              : 
     546              : void
     547     25999626 : PointerVisitor::visit (AST::MatchCase &arm)
     548              : {
     549     25999626 :   visit (arm.get_arm ());
     550     25999626 :   reseat (arm.get_expr_ptr ());
     551     25999626 : }
     552              : 
     553              : void
     554      2456661 : PointerVisitor::visit (AST::MatchExpr &expr)
     555              : {
     556      2456661 :   visit_outer_attrs (expr);
     557      2456661 :   visit_inner_attrs (expr);
     558      2456661 :   reseat (expr.get_scrutinee_expr_ptr ());
     559     28456287 :   for (auto &arm : expr.get_match_cases ())
     560     25999626 :     visit (arm);
     561      2456661 : }
     562              : 
     563              : void
     564            0 : PointerVisitor::visit (AST::AwaitExpr &expr)
     565              : {
     566            0 :   visit_outer_attrs (expr);
     567            0 :   reseat (expr.get_awaited_expr ());
     568            0 : }
     569              : 
     570              : void
     571            0 : PointerVisitor::visit (AST::AsyncBlockExpr &expr)
     572              : {
     573            0 :   visit_outer_attrs (expr);
     574            0 :   reseat (expr.get_block_expr ());
     575            0 : }
     576              : 
     577              : void
     578          102 : PointerVisitor::visit (AST::InlineAsm &expr)
     579              : {
     580          102 :   visit_outer_attrs (expr);
     581          102 :   using RegisterType = AST::InlineAsmOperand::RegisterType;
     582          231 :   for (auto &operand : expr.get_operands ())
     583              :     {
     584          129 :       switch (operand.get_register_type ())
     585              :         {
     586           51 :         case RegisterType::In:
     587           51 :           {
     588           51 :             reseat (operand.get_in ().expr);
     589           51 :             break;
     590              :           }
     591           72 :         case RegisterType::Out:
     592           72 :           {
     593           72 :             reseat (operand.get_out ().expr);
     594           72 :             break;
     595              :           }
     596            0 :         case RegisterType::InOut:
     597            0 :           {
     598            0 :             reseat (operand.get_in_out ().expr);
     599            0 :             break;
     600              :           }
     601            6 :         case RegisterType::SplitInOut:
     602            6 :           {
     603            6 :             auto split = operand.get_split_in_out ();
     604            6 :             reseat (split.in_expr);
     605            6 :             reseat (split.out_expr);
     606            6 :             break;
     607            6 :           }
     608            0 :         case RegisterType::Const:
     609            0 :           {
     610            0 :             reseat (operand.get_const ().anon_const.get_inner_expr_ptr ());
     611            0 :             break;
     612              :           }
     613            0 :         case RegisterType::Sym:
     614            0 :           {
     615            0 :             reseat (operand.get_sym ().expr);
     616            0 :             break;
     617              :           }
     618            0 :         case RegisterType::Label:
     619            0 :           {
     620            0 :             reseat (operand.get_label ().expr);
     621            0 :             break;
     622              :           }
     623              :         }
     624          102 :     }
     625          102 : }
     626              : 
     627              : void
     628         6630 : PointerVisitor::visit (AST::LlvmInlineAsm &expr)
     629              : {
     630         6630 :   visit_outer_attrs (expr);
     631              : 
     632        16014 :   for (auto &output : expr.get_outputs ())
     633         9384 :     reseat (output.expr);
     634              : 
     635        13812 :   for (auto &input : expr.get_inputs ())
     636         7182 :     reseat (input.expr);
     637         6630 : }
     638              : 
     639              : void
     640      2157314 : PointerVisitor::visit (AST::TypeParam &param)
     641              : {
     642      2157314 :   visit_outer_attrs (param);
     643              :   // FIXME: Can we do macro expansion here?
     644      2782950 :   for (auto &bound : param.get_type_param_bounds ())
     645       625636 :     visit (bound);
     646      2157314 :   if (param.has_type ())
     647         9324 :     reseat (param.get_type_ptr ());
     648      2157314 : }
     649              : 
     650              : void
     651       307874 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
     652              : {
     653       308189 :   for (auto &lifetime : item.get_for_lifetimes ())
     654          315 :     visit (lifetime);
     655       307874 :   reseat (item.get_type_ptr ());
     656              :   // FIXME: Likewise?
     657       630256 :   for (auto &param : item.get_type_param_bounds ())
     658       322382 :     visit (param);
     659       307874 : }
     660              : 
     661              : void
     662      4166574 : PointerVisitor::visit (AST::FunctionParam &param)
     663              : {
     664      4166574 :   visit_outer_attrs (param);
     665      4166574 :   if (param.has_name ())
     666      4166574 :     reseat (param.get_pattern_ptr ());
     667              : 
     668      4166574 :   reseat (param.get_type_ptr ());
     669      4166574 : }
     670              : 
     671              : void
     672      2287618 : PointerVisitor::visit (AST::SelfParam &param)
     673              : {
     674      2287618 :   visit_outer_attrs (param);
     675              : 
     676      2287618 :   if (param.has_lifetime ())
     677      1045539 :     visit (param.get_lifetime ());
     678              : 
     679      2287618 :   if (param.has_type ())
     680         3813 :     reseat (param.get_type_ptr ());
     681      2287618 : }
     682              : 
     683              : void
     684        73831 : PointerVisitor::visit (AST::Module &module)
     685              : {
     686        73831 :   visit_outer_attrs (module);
     687        73831 :   visit (module.get_visibility ());
     688        73831 :   visit_inner_attrs (module);
     689      3211613 :   for (auto &item : module.get_items ())
     690      3137782 :     reseat (item);
     691        73831 : }
     692              : 
     693              : void
     694      3488500 : PointerVisitor::visit_function_params (AST::Function &function)
     695              : {
     696      9945511 :   for (auto &param : function.get_function_params ())
     697      6457011 :     visit (param);
     698      3488500 : }
     699              : 
     700              : void
     701      3488500 : PointerVisitor::visit (AST::Function &function)
     702              : {
     703      3488500 :   visit_outer_attrs (function);
     704      3488500 :   visit (function.get_visibility ());
     705      3488500 :   visit (function.get_qualifiers ());
     706      3922010 :   for (auto &generic : function.get_generic_params ())
     707       433510 :     visit (generic);
     708              : 
     709      3488500 :   visit_function_params (function);
     710              : 
     711      3488500 :   if (function.has_return_type ())
     712      3029948 :     reseat (function.get_return_type_ptr ());
     713      3488500 :   if (function.has_where_clause ())
     714       121391 :     visit (function.get_where_clause ());
     715      3488500 :   if (function.has_body ())
     716      3187087 :     reseat (*function.get_definition ());
     717      3488500 : }
     718              : 
     719              : void
     720      1411850 : PointerVisitor::visit (AST::TypeAlias &type_alias)
     721              : {
     722      1411850 :   visit_outer_attrs (type_alias);
     723      1411850 :   visit (type_alias.get_visibility ());
     724      1411995 :   for (auto &generic : type_alias.get_generic_params ())
     725          145 :     visit (generic);
     726      1411850 :   if (type_alias.has_where_clause ())
     727            0 :     visit (type_alias.get_where_clause ());
     728      1411850 :   reseat (type_alias.get_type_aliased_ptr ());
     729      1411850 : }
     730              : 
     731              : void
     732       235422 : PointerVisitor::visit (AST::StructField &field)
     733              : {
     734       235422 :   visit_outer_attrs (field);
     735       235422 :   visit (field.get_visibility ());
     736       235422 :   reseat (field.get_field_type_ptr ());
     737       235422 : }
     738              : 
     739              : void
     740       284326 : PointerVisitor::visit (AST::TupleField &field)
     741              : {
     742       284326 :   visit_outer_attrs (field);
     743       284326 :   visit (field.get_visibility ());
     744       284326 :   reseat (field.get_field_type_ptr ());
     745       284326 : }
     746              : 
     747              : void
     748         1880 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
     749              : {
     750         1880 :   PointerVisitor::visit (static_cast<EnumItem &> (item));
     751         1880 :   reseat (item.get_expr_ptr ());
     752         1880 : }
     753              : 
     754              : void
     755       399767 : PointerVisitor::visit (AST::ConstantItem &const_item)
     756              : {
     757       399767 :   visit_outer_attrs (const_item);
     758       399767 :   visit (const_item.get_visibility ());
     759       399767 :   reseat (const_item.get_type_ptr ());
     760       399767 :   if (const_item.has_expr ())
     761       388796 :     reseat (const_item.get_expr_ptr ());
     762       399767 : }
     763              : 
     764              : void
     765        20349 : PointerVisitor::visit (AST::StaticItem &static_item)
     766              : {
     767        20349 :   visit_outer_attrs (static_item);
     768        20349 :   visit (static_item.get_visibility ());
     769        20349 :   reseat (static_item.get_type_ptr ());
     770        20349 :   reseat (static_item.get_expr_ptr ());
     771        20349 : }
     772              : 
     773              : void
     774        53858 : PointerVisitor::visit (AST::Trait &trait)
     775              : {
     776        53858 :   visit_outer_attrs (trait);
     777        53858 :   visit (trait.get_visibility ());
     778              : 
     779        53858 :   visit_inner_attrs (trait);
     780              : 
     781        53858 :   visit (trait.get_implicit_self ());
     782              : 
     783        73748 :   for (auto &generic : trait.get_generic_params ())
     784        19890 :     visit (generic);
     785              : 
     786        53858 :   if (trait.has_where_clause ())
     787           28 :     visit (trait.get_where_clause ());
     788              : 
     789        77440 :   for (auto &bound : trait.get_type_param_bounds ())
     790        23582 :     visit (bound);
     791              : 
     792       175633 :   for (auto &item : trait.get_trait_items ())
     793       121775 :     reseat (item);
     794        53858 : }
     795              : 
     796              : void
     797        87289 : PointerVisitor::visit (AST::InherentImpl &impl)
     798              : {
     799        87289 :   visit_outer_attrs (impl);
     800        87289 :   visit (impl.get_visibility ());
     801              : 
     802       165764 :   for (auto &generic : impl.get_generic_params ())
     803        78475 :     visit (generic);
     804        87289 :   if (impl.has_where_clause ())
     805          867 :     visit (impl.get_where_clause ());
     806        87289 :   reseat (impl.get_type_ptr ());
     807        87289 :   visit_inner_attrs (impl);
     808       719520 :   for (auto &item : impl.get_impl_items ())
     809       632231 :     reseat (item);
     810        87289 : }
     811              : 
     812              : void
     813      1860151 : PointerVisitor::visit (AST::TraitImpl &impl)
     814              : {
     815      1860151 :   visit_outer_attrs (impl);
     816      1860151 :   visit (impl.get_visibility ());
     817              : 
     818      3688576 :   for (auto &generic : impl.get_generic_params ())
     819      1828425 :     visit (generic);
     820      1860151 :   if (impl.has_where_clause ())
     821       101219 :     visit (impl.get_where_clause ());
     822      1860151 :   reseat (impl.get_type_ptr ());
     823      1860151 :   visit (impl.get_trait_path ());
     824      1860151 :   visit_inner_attrs (impl);
     825      4515149 :   for (auto &item : impl.get_impl_items ())
     826      2654998 :     reseat (item);
     827      1860151 : }
     828              : 
     829              : void
     830            5 : PointerVisitor::visit (AST::ExternalStaticItem &item)
     831              : {
     832            5 :   visit_outer_attrs (item);
     833            5 :   visit (item.get_visibility ());
     834            5 :   reseat (item.get_type_ptr ());
     835            5 : }
     836              : 
     837              : void
     838        18492 : PointerVisitor::visit (AST::ExternBlock &block)
     839              : {
     840        18492 :   visit_outer_attrs (block);
     841        18492 :   visit (block.get_visibility ());
     842        18492 :   visit_inner_attrs (block);
     843       264988 :   for (auto &item : block.get_extern_items ())
     844       246496 :     reseat (item);
     845        18492 : }
     846              : 
     847              : void
     848     11186766 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
     849              : {
     850     11186766 :   if (pattern.has_subpattern ())
     851         7474 :     reseat (pattern.get_subpattern_ptr ());
     852     11186766 : }
     853              : 
     854              : void
     855        41138 : PointerVisitor::visit (AST::RangePattern &pattern)
     856              : {
     857              :   // FIXME: So should this be reseat() instead? Can we have macro invocations as
     858              :   // patterns in range patterns?
     859        41138 :   if (pattern.get_has_lower_bound ())
     860        41138 :     visit (pattern.get_lower_bound ());
     861        41138 :   if (pattern.get_has_upper_bound ())
     862        41138 :     visit (pattern.get_upper_bound ());
     863        41138 : }
     864              : 
     865              : void
     866       111647 : PointerVisitor::visit (AST::ReferencePattern &pattern)
     867              : {
     868       111647 :   reseat (pattern.get_referenced_pattern_ptr ());
     869       111647 : }
     870              : 
     871              : void
     872          180 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
     873              : {
     874          180 :   visit_outer_attrs (field);
     875          180 :   reseat (field.get_index_pattern_ptr ());
     876          180 : }
     877              : 
     878              : void
     879        23331 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
     880              : {
     881        23331 :   visit_outer_attrs (field);
     882        23331 :   reseat (field.get_ident_pattern_ptr ());
     883        23331 : }
     884              : 
     885              : void
     886       427918 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
     887              : {
     888       871384 :   for (auto &pattern : tuple_items.get_patterns ())
     889       443466 :     reseat (pattern);
     890       427918 : }
     891              : 
     892              : void
     893         4624 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
     894              : {
     895         4924 :   for (auto &lower : tuple_items.get_lower_patterns ())
     896          300 :     reseat (lower);
     897         4854 :   for (auto &upper : tuple_items.get_upper_patterns ())
     898          230 :     reseat (upper);
     899         4624 : }
     900              : 
     901              : void
     902      1383648 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
     903              : {
     904      4601204 :   for (auto &pattern : tuple_items.get_patterns ())
     905      3217556 :     reseat (pattern);
     906      1383648 : }
     907              : 
     908              : void
     909          190 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
     910              : {
     911          355 :   for (auto &lower : tuple_items.get_lower_patterns ())
     912          165 :     reseat (lower);
     913          370 :   for (auto &upper : tuple_items.get_upper_patterns ())
     914          180 :     reseat (upper);
     915          190 : }
     916              : 
     917              : void
     918          250 : PointerVisitor::visit (AST::GroupedPattern &pattern)
     919              : {
     920          250 :   reseat (pattern.get_pattern_in_parens_ptr ());
     921          250 : }
     922              : 
     923              : void
     924         7341 : PointerVisitor::visit (AST::SlicePattern &pattern)
     925              : {
     926        21730 :   for (auto &pat : pattern.get_patterns ())
     927        14389 :     reseat (pat);
     928         7341 : }
     929              : 
     930              : void
     931        20576 : PointerVisitor::visit (AST::AltPattern &pattern)
     932              : {
     933        74664 :   for (auto &alt : pattern.get_alts ())
     934        54088 :     reseat (alt);
     935        20576 : }
     936              : 
     937              : void
     938      2102308 : PointerVisitor::visit (AST::LetStmt &stmt)
     939              : {
     940      2102308 :   visit_outer_attrs (stmt);
     941      2102308 :   reseat (stmt.get_pattern_ptr ());
     942      2102308 :   if (stmt.has_type ())
     943       236586 :     reseat (stmt.get_type_ptr ());
     944      2102308 :   if (stmt.has_init_expr ())
     945      2036680 :     reseat (stmt.get_init_expr_ptr ());
     946      2102308 : }
     947              : 
     948              : void
     949      2205717 : PointerVisitor::visit (AST::ExprStmt &stmt)
     950              : {
     951      2205717 :   reseat (stmt.get_expr_ptr ());
     952      2205717 : }
     953              : 
     954              : void
     955         5168 : PointerVisitor::visit (AST::ParenthesisedType &type)
     956              : {
     957         5168 :   reseat (type.get_type_in_parens ());
     958         5168 : }
     959              : 
     960              : void
     961        68939 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
     962              : {
     963              :   // FIXME: Do we need to reseat here?
     964        68939 :   visit (type.get_trait_bound ());
     965        68939 : }
     966              : 
     967              : void
     968        14189 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
     969              : {
     970              :   // FIXME: Do we need to reseat here?
     971        14189 :   visit (type.get_trait_bound ());
     972        14189 : }
     973              : 
     974              : void
     975       513375 : PointerVisitor::visit (AST::TupleType &type)
     976              : {
     977      1710582 :   for (auto &elem : type.get_elems ())
     978      1197207 :     reseat (elem);
     979       513375 : }
     980              : 
     981              : void
     982       686374 : PointerVisitor::visit (AST::RawPointerType &type)
     983              : {
     984       686374 :   reseat (type.get_type_pointed_to_ptr ());
     985       686374 : }
     986              : 
     987              : void
     988      4141625 : PointerVisitor::visit (AST::ReferenceType &type)
     989              : {
     990      4141625 :   visit (type.get_lifetime ());
     991      4141625 :   reseat (type.get_type_ptr ());
     992      4141625 : }
     993              : 
     994              : void
     995       163800 : PointerVisitor::visit (AST::ArrayType &type)
     996              : {
     997       163800 :   reseat (type.get_elem_type_ptr ());
     998       163800 :   visit (type.get_size_expr ());
     999       163800 : }
    1000              : 
    1001              : void
    1002       331627 : PointerVisitor::visit (AST::SliceType &type)
    1003              : {
    1004       331627 :   reseat (type.get_elem_type_ptr ());
    1005       331627 : }
    1006              : 
    1007              : void
    1008       896458 : PointerVisitor::visit (AST::MaybeNamedParam &param)
    1009              : {
    1010       896458 :   visit_outer_attrs (param);
    1011       896458 :   reseat (param.get_type_ptr ());
    1012       896458 : }
    1013              : 
    1014              : void
    1015       149264 : PointerVisitor::visit (AST::BareFunctionType &type)
    1016              : {
    1017       149276 :   for (auto &lifetime : type.get_for_lifetimes ())
    1018           12 :     visit (lifetime);
    1019       149264 :   visit (type.get_function_qualifiers ());
    1020      1045722 :   for (auto &param : type.get_function_params ())
    1021       896458 :     visit (param);
    1022       149264 :   if (type.is_variadic ())
    1023        45696 :     for (auto attr : type.get_variadic_attr ())
    1024            0 :       visit (attr);
    1025       149264 :   if (type.has_return_type ())
    1026       146883 :     reseat (type.get_return_type_ptr ());
    1027       149264 : }
    1028              : 
    1029              : void
    1030            0 : PointerVisitor::visit (AST::FormatArgs &)
    1031              : {
    1032              :   // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
    1033            0 : }
    1034              : 
    1035              : void
    1036           45 : PointerVisitor::visit (AST::OffsetOf &offset_of)
    1037              : {
    1038           45 :   reseat (offset_of.get_type_ptr ());
    1039           45 : }
    1040              : 
    1041              : void
    1042         2819 : PointerVisitor::visit (AST::VariadicParam &param)
    1043              : {
    1044         2819 :   if (param.has_pattern ())
    1045           33 :     reseat (param.get_pattern_ptr ());
    1046         2819 : }
    1047              : 
    1048              : } // namespace AST
    1049              : } // 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.