| // Copyright (C) 2025-2026 Free Software Foundation, Inc. | |
| // This file is part of GCC. | |
| // GCC is free software; you can redistribute it and/or modify it under | |
| // the terms of the GNU General Public License as published by the Free | |
| // Software Foundation; either version 3, or (at your option) any later | |
| // version. | |
| // GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| // WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| // for more details. | |
| // You should have received a copy of the GNU General Public License | |
| // along with GCC; see the file COPYING3. If not see | |
| // <http://www.gnu.org/licenses/>. | |
| #include "rust-ast-pointer-visitor.h" | |
| #include "rust-ast-visitor.h" | |
| #include "rust-ast-full.h" | |
| namespace Rust { | |
| namespace AST { | |
| void | |
| PointerVisitor::visit (AST::Crate &crate) | |
| { | |
| visit_inner_attrs (crate); | |
| for (auto &item : crate.items) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AttrInputMetaItemContainer &input) | |
| { | |
| // FIXME: I think we might actually have to reseat sub-items for macro | |
| // invocations within attributes correct? | |
| for (auto &item : input.get_items ()) | |
| visit (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::IdentifierExpr &ident_expr) | |
| { | |
| visit_outer_attrs (ident_expr); | |
| } | |
| void | |
| PointerVisitor::visit (AST::LifetimeParam &lifetime_param) | |
| { | |
| visit_outer_attrs (lifetime_param); | |
| // Nothing to do for lifetimes right? | |
| } | |
| void | |
| PointerVisitor::visit (AST::ConstGenericParam &const_param) | |
| { | |
| visit_outer_attrs (const_param); | |
| if (const_param.has_type ()) | |
| reseat (const_param.get_type_ptr ()); | |
| if (const_param.has_default_value ()) | |
| visit (const_param.get_default_value_unchecked ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::PathInExpression &path) | |
| { | |
| visit_outer_attrs (path); | |
| if (!path.is_lang_item ()) | |
| for (auto &segment : path.get_segments ()) | |
| visit (segment); | |
| } | |
| void | |
| PointerVisitor::visit (GenericArgsBinding &binding) | |
| { | |
| reseat (binding.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypePathSegmentGeneric &segment) | |
| { | |
| if (segment.has_generic_args ()) | |
| visit (segment.get_generic_args ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypePathFunction &tpf) | |
| { | |
| for (auto &input : tpf.get_params ()) | |
| reseat (input); | |
| if (tpf.has_return_type ()) | |
| reseat (tpf.get_return_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypePathSegmentFunction &segment) | |
| { | |
| // FIXME: No reseating here correct? No macros possible or desugar? | |
| visit (segment.get_type_path_function ()); | |
| visit (segment.get_ident_segment ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::GenericArgs &args) | |
| { | |
| // Nothing to do for lifetimes? | |
| // for (auto &lifetime : args.get_lifetime_args ()) | |
| // reseat (lifetime); | |
| // FIXME: Actually this can probably be a macro invocation, so we need to | |
| // reseat them? | |
| for (auto &generic : args.get_generic_args ()) | |
| visit (generic); | |
| for (auto &binding : args.get_binding_args ()) | |
| visit (binding); | |
| } | |
| void | |
| PointerVisitor::visit (AST::PathExprSegment &segment) | |
| { | |
| visit (segment.get_ident_segment ()); | |
| if (segment.has_generic_args ()) | |
| visit (segment.get_generic_args ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypePath &path) | |
| { | |
| for (auto &segment : path.get_segments ()) | |
| visit (segment); | |
| } | |
| void | |
| PointerVisitor::visit (AST::QualifiedPathInExpression &path) | |
| { | |
| visit_outer_attrs (path); | |
| visit (path.get_qualified_path_type ()); | |
| for (auto &segment : path.get_segments ()) | |
| visit (segment); | |
| } | |
| void | |
| PointerVisitor::visit (AST::QualifiedPathType &path) | |
| { | |
| reseat (path.get_type_ptr ()); | |
| if (path.has_as_clause ()) | |
| visit (path.get_as_type_path ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MetaItemPathExpr &meta_item) | |
| { | |
| visit (meta_item.get_path ()); | |
| reseat (meta_item.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::BorrowExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_borrowed_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::DereferenceExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_dereferenced_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ErrorPropagationExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_propagating_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::NegationExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_negated_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_left_expr_ptr ()); | |
| reseat (expr.get_right_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ComparisonExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_left_expr_ptr ()); | |
| reseat (expr.get_right_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::LazyBooleanExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_left_expr_ptr ()); | |
| reseat (expr.get_right_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypeCastExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_casted_expr_ptr ()); | |
| reseat (expr.get_type_to_cast_to_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AssignmentExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_left_expr_ptr ()); | |
| reseat (expr.get_right_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::CompoundAssignmentExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_left_expr_ptr ()); | |
| reseat (expr.get_right_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::GroupedExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| visit_inner_attrs (expr); | |
| reseat (expr.get_expr_in_parens_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArrayElemsValues &elems) | |
| { | |
| for (auto &value : elems.get_values ()) | |
| reseat (value); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArrayElemsCopied &elems) | |
| { | |
| reseat (elems.get_elem_to_copy_ptr ()); | |
| reseat (elems.get_num_copies_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArrayExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| visit_inner_attrs (expr); | |
| visit (expr.get_array_elems ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArrayIndexExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_array_expr_ptr ()); | |
| reseat (expr.get_index_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| visit_inner_attrs (expr); | |
| for (auto &elem : expr.get_tuple_elems ()) | |
| reseat (elem); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleIndexExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_tuple_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field) | |
| { | |
| reseat (field.get_value_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructExprFieldIndexValue &field) | |
| { | |
| reseat (field.get_value_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructBase &base) | |
| { | |
| reseat (base.get_base_struct_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::CallExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_function_expr_ptr ()); | |
| for (auto ¶m : expr.get_params ()) | |
| reseat (param); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MethodCallExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_receiver_expr_ptr ()); | |
| visit (expr.get_method_name ()); | |
| for (auto ¶m : expr.get_params ()) | |
| reseat (param); | |
| } | |
| void | |
| PointerVisitor::visit (AST::FieldAccessExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_receiver_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ClosureExprInner &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| // TODO: Actually we need to handle macro invocations as closure parameters so | |
| // this needs to be a reseat | |
| for (auto ¶m : expr.get_params ()) | |
| visit (param); | |
| reseat (expr.get_definition_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::BlockExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| visit_inner_attrs (expr); | |
| if (expr.has_label ()) | |
| visit (expr.get_label ()); | |
| for (auto &stmt : expr.get_statements ()) | |
| reseat (stmt); | |
| if (expr.has_tail_expr ()) | |
| reseat (expr.get_tail_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AnonConst &expr) | |
| { | |
| if (!expr.is_deferred ()) | |
| reseat (expr.get_inner_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ClosureExprInnerTyped &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| // TODO: Same as ClosureExprInner | |
| for (auto ¶m : expr.get_params ()) | |
| visit (param); | |
| reseat (expr.get_return_type_ptr ()); | |
| reseat (expr.get_definition_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ClosureParam ¶m) | |
| { | |
| visit_outer_attrs (param); | |
| reseat (param.get_pattern_ptr ()); | |
| if (param.has_type_given ()) | |
| reseat (param.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ContinueExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| if (expr.has_label ()) | |
| visit (expr.get_label_unchecked ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::BreakExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| if (expr.has_label ()) | |
| visit (expr.get_label_unchecked ()); | |
| if (expr.has_break_expr ()) | |
| reseat (expr.get_break_expr_ptr_unchecked ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangeFromToExpr &expr) | |
| { | |
| reseat (expr.get_from_expr_ptr ()); | |
| reseat (expr.get_to_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangeFromExpr &expr) | |
| { | |
| reseat (expr.get_from_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangeToExpr &expr) | |
| { | |
| reseat (expr.get_to_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangeFromToInclExpr &expr) | |
| { | |
| reseat (expr.get_from_expr_ptr ()); | |
| reseat (expr.get_to_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangeToInclExpr &expr) | |
| { | |
| reseat (expr.get_to_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ReturnExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| if (expr.has_returned_expr ()) | |
| reseat (expr.get_returned_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TryExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_block_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::BoxExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_boxed_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::UnsafeBlockExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_block_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::LoopExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| if (expr.has_loop_label ()) | |
| visit (expr.get_loop_label ()); | |
| reseat (expr.get_loop_block_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::WhileLoopExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| if (expr.has_loop_label ()) | |
| visit (expr.get_loop_label ()); | |
| reseat (expr.get_predicate_expr_ptr ()); | |
| reseat (expr.get_loop_block_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::WhileLetLoopExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_pattern ()); | |
| if (expr.has_loop_label ()) | |
| visit (expr.get_loop_label ()); | |
| reseat (expr.get_scrutinee_expr_ptr ()); | |
| reseat (expr.get_loop_block_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ForLoopExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_pattern_ptr ()); | |
| reseat (expr.get_iterator_expr_ptr ()); | |
| if (expr.has_loop_label ()) | |
| visit (expr.get_loop_label ()); | |
| reseat (expr.get_loop_block_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::IfExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_condition_expr_ptr ()); | |
| visit (expr.get_if_block ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::IfLetExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_pattern ()); | |
| reseat (expr.get_value_expr_ptr ()); | |
| visit (expr.get_if_block ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MatchArm &arm) | |
| { | |
| visit_outer_attrs (arm); | |
| reseat (arm.get_pattern ()); | |
| if (arm.has_match_arm_guard ()) | |
| reseat (arm.get_guard_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MatchCase &arm) | |
| { | |
| visit (arm.get_arm ()); | |
| reseat (arm.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MatchExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| visit_inner_attrs (expr); | |
| reseat (expr.get_scrutinee_expr_ptr ()); | |
| for (auto &arm : expr.get_match_cases ()) | |
| visit (arm); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AwaitExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_awaited_expr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AsyncBlockExpr &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| reseat (expr.get_block_expr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::InlineAsm &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| using RegisterType = AST::InlineAsmOperand::RegisterType; | |
| for (auto &operand : expr.get_operands ()) | |
| { | |
| switch (operand.get_register_type ()) | |
| { | |
| case RegisterType::In: | |
| { | |
| reseat (operand.get_in ().expr); | |
| break; | |
| } | |
| case RegisterType::Out: | |
| { | |
| reseat (operand.get_out ().expr); | |
| break; | |
| } | |
| case RegisterType::InOut: | |
| { | |
| reseat (operand.get_in_out ().expr); | |
| break; | |
| } | |
| case RegisterType::SplitInOut: | |
| { | |
| auto split = operand.get_split_in_out (); | |
| reseat (split.in_expr); | |
| reseat (split.out_expr); | |
| break; | |
| } | |
| case RegisterType::Const: | |
| { | |
| reseat (operand.get_const ().anon_const.get_inner_expr_ptr ()); | |
| break; | |
| } | |
| case RegisterType::Sym: | |
| { | |
| reseat (operand.get_sym ().expr); | |
| break; | |
| } | |
| case RegisterType::Label: | |
| { | |
| reseat (operand.get_label ().expr); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| void | |
| PointerVisitor::visit (AST::LlvmInlineAsm &expr) | |
| { | |
| visit_outer_attrs (expr); | |
| for (auto &output : expr.get_outputs ()) | |
| reseat (output.expr); | |
| for (auto &input : expr.get_inputs ()) | |
| reseat (input.expr); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypeParam ¶m) | |
| { | |
| visit_outer_attrs (param); | |
| // FIXME: Can we do macro expansion here? | |
| for (auto &bound : param.get_type_param_bounds ()) | |
| visit (bound); | |
| if (param.has_type ()) | |
| reseat (param.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item) | |
| { | |
| for (auto &lifetime : item.get_for_lifetimes ()) | |
| visit (lifetime); | |
| reseat (item.get_type_ptr ()); | |
| // FIXME: Likewise? | |
| for (auto ¶m : item.get_type_param_bounds ()) | |
| visit (param); | |
| } | |
| void | |
| PointerVisitor::visit (AST::FunctionParam ¶m) | |
| { | |
| visit_outer_attrs (param); | |
| if (param.has_name ()) | |
| reseat (param.get_pattern_ptr ()); | |
| reseat (param.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::SelfParam ¶m) | |
| { | |
| visit_outer_attrs (param); | |
| if (param.has_lifetime ()) | |
| visit (param.get_lifetime ()); | |
| if (param.has_type ()) | |
| reseat (param.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::Module &module) | |
| { | |
| visit_outer_attrs (module); | |
| visit (module.get_visibility ()); | |
| visit_inner_attrs (module); | |
| for (auto &item : module.get_items ()) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit_function_params (AST::Function &function) | |
| { | |
| for (auto ¶m : function.get_function_params ()) | |
| visit (param); | |
| } | |
| void | |
| PointerVisitor::visit (AST::Function &function) | |
| { | |
| visit_outer_attrs (function); | |
| visit (function.get_visibility ()); | |
| visit (function.get_qualifiers ()); | |
| for (auto &generic : function.get_generic_params ()) | |
| visit (generic); | |
| visit_function_params (function); | |
| if (function.has_return_type ()) | |
| reseat (function.get_return_type_ptr ()); | |
| if (function.has_where_clause ()) | |
| visit (function.get_where_clause ()); | |
| if (function.has_body ()) | |
| reseat (*function.get_definition ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TypeAlias &type_alias) | |
| { | |
| visit_outer_attrs (type_alias); | |
| visit (type_alias.get_visibility ()); | |
| for (auto &generic : type_alias.get_generic_params ()) | |
| visit (generic); | |
| if (type_alias.has_where_clause ()) | |
| visit (type_alias.get_where_clause ()); | |
| reseat (type_alias.get_type_aliased_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructField &field) | |
| { | |
| visit_outer_attrs (field); | |
| visit (field.get_visibility ()); | |
| reseat (field.get_field_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleField &field) | |
| { | |
| visit_outer_attrs (field); | |
| visit (field.get_visibility ()); | |
| reseat (field.get_field_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::EnumItemDiscriminant &item) | |
| { | |
| PointerVisitor::visit (static_cast<EnumItem &> (item)); | |
| reseat (item.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ConstantItem &const_item) | |
| { | |
| visit_outer_attrs (const_item); | |
| visit (const_item.get_visibility ()); | |
| reseat (const_item.get_type_ptr ()); | |
| if (const_item.has_expr ()) | |
| reseat (const_item.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StaticItem &static_item) | |
| { | |
| visit_outer_attrs (static_item); | |
| visit (static_item.get_visibility ()); | |
| reseat (static_item.get_type_ptr ()); | |
| reseat (static_item.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::Trait &trait) | |
| { | |
| visit_outer_attrs (trait); | |
| visit (trait.get_visibility ()); | |
| visit_inner_attrs (trait); | |
| visit (trait.get_implicit_self ()); | |
| for (auto &generic : trait.get_generic_params ()) | |
| visit (generic); | |
| if (trait.has_where_clause ()) | |
| visit (trait.get_where_clause ()); | |
| for (auto &bound : trait.get_type_param_bounds ()) | |
| visit (bound); | |
| for (auto &item : trait.get_trait_items ()) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::InherentImpl &impl) | |
| { | |
| visit_outer_attrs (impl); | |
| visit (impl.get_visibility ()); | |
| for (auto &generic : impl.get_generic_params ()) | |
| visit (generic); | |
| if (impl.has_where_clause ()) | |
| visit (impl.get_where_clause ()); | |
| reseat (impl.get_type_ptr ()); | |
| visit_inner_attrs (impl); | |
| for (auto &item : impl.get_impl_items ()) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TraitImpl &impl) | |
| { | |
| visit_outer_attrs (impl); | |
| visit (impl.get_visibility ()); | |
| for (auto &generic : impl.get_generic_params ()) | |
| visit (generic); | |
| if (impl.has_where_clause ()) | |
| visit (impl.get_where_clause ()); | |
| reseat (impl.get_type_ptr ()); | |
| visit (impl.get_trait_path ()); | |
| visit_inner_attrs (impl); | |
| for (auto &item : impl.get_impl_items ()) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ExternalStaticItem &item) | |
| { | |
| visit_outer_attrs (item); | |
| visit (item.get_visibility ()); | |
| reseat (item.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ExternBlock &block) | |
| { | |
| visit_outer_attrs (block); | |
| visit (block.get_visibility ()); | |
| visit_inner_attrs (block); | |
| for (auto &item : block.get_extern_items ()) | |
| reseat (item); | |
| } | |
| void | |
| PointerVisitor::visit (AST::IdentifierPattern &pattern) | |
| { | |
| if (pattern.has_subpattern ()) | |
| reseat (pattern.get_subpattern_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RangePattern &pattern) | |
| { | |
| // FIXME: So should this be reseat() instead? Can we have macro invocations as | |
| // patterns in range patterns? | |
| if (pattern.get_has_lower_bound ()) | |
| visit (pattern.get_lower_bound ()); | |
| if (pattern.get_has_upper_bound ()) | |
| visit (pattern.get_upper_bound ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ReferencePattern &pattern) | |
| { | |
| reseat (pattern.get_referenced_pattern_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructPatternFieldTuplePat &field) | |
| { | |
| visit_outer_attrs (field); | |
| reseat (field.get_index_pattern_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::StructPatternFieldIdentPat &field) | |
| { | |
| visit_outer_attrs (field); | |
| reseat (field.get_ident_pattern_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items) | |
| { | |
| for (auto &pattern : tuple_items.get_patterns ()) | |
| reseat (pattern); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items) | |
| { | |
| for (auto &lower : tuple_items.get_lower_patterns ()) | |
| reseat (lower); | |
| for (auto &upper : tuple_items.get_upper_patterns ()) | |
| reseat (upper); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items) | |
| { | |
| for (auto &pattern : tuple_items.get_patterns ()) | |
| reseat (pattern); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items) | |
| { | |
| for (auto &lower : tuple_items.get_lower_patterns ()) | |
| reseat (lower); | |
| for (auto &upper : tuple_items.get_upper_patterns ()) | |
| reseat (upper); | |
| } | |
| void | |
| PointerVisitor::visit (AST::GroupedPattern &pattern) | |
| { | |
| reseat (pattern.get_pattern_in_parens_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::SlicePattern &pattern) | |
| { | |
| for (auto &pat : pattern.get_patterns ()) | |
| reseat (pat); | |
| } | |
| void | |
| PointerVisitor::visit (AST::AltPattern &pattern) | |
| { | |
| for (auto &alt : pattern.get_alts ()) | |
| reseat (alt); | |
| } | |
| void | |
| PointerVisitor::visit (AST::LetStmt &stmt) | |
| { | |
| visit_outer_attrs (stmt); | |
| reseat (stmt.get_pattern_ptr ()); | |
| if (stmt.has_type ()) | |
| reseat (stmt.get_type_ptr ()); | |
| if (stmt.has_init_expr ()) | |
| reseat (stmt.get_init_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ExprStmt &stmt) | |
| { | |
| reseat (stmt.get_expr_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ParenthesisedType &type) | |
| { | |
| reseat (type.get_type_in_parens ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ImplTraitTypeOneBound &type) | |
| { | |
| // FIXME: Do we need to reseat here? | |
| visit (type.get_trait_bound ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TraitObjectTypeOneBound &type) | |
| { | |
| // FIXME: Do we need to reseat here? | |
| visit (type.get_trait_bound ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::TupleType &type) | |
| { | |
| for (auto &elem : type.get_elems ()) | |
| reseat (elem); | |
| } | |
| void | |
| PointerVisitor::visit (AST::RawPointerType &type) | |
| { | |
| reseat (type.get_type_pointed_to_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ReferenceType &type) | |
| { | |
| visit (type.get_lifetime ()); | |
| reseat (type.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::ArrayType &type) | |
| { | |
| reseat (type.get_elem_type_ptr ()); | |
| visit (type.get_size_expr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::SliceType &type) | |
| { | |
| reseat (type.get_elem_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::MaybeNamedParam ¶m) | |
| { | |
| visit_outer_attrs (param); | |
| reseat (param.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::BareFunctionType &type) | |
| { | |
| for (auto &lifetime : type.get_for_lifetimes ()) | |
| visit (lifetime); | |
| visit (type.get_function_qualifiers ()); | |
| for (auto ¶m : type.get_function_params ()) | |
| visit (param); | |
| if (type.is_variadic ()) | |
| for (auto attr : type.get_variadic_attr ()) | |
| visit (attr); | |
| if (type.has_return_type ()) | |
| reseat (type.get_return_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::FormatArgs &) | |
| { | |
| // FIXME: Do we have anything to do? any subnodes to visit? Probably, right? | |
| } | |
| void | |
| PointerVisitor::visit (AST::OffsetOf &offset_of) | |
| { | |
| reseat (offset_of.get_type_ptr ()); | |
| } | |
| void | |
| PointerVisitor::visit (AST::VariadicParam ¶m) | |
| { | |
| if (param.has_pattern ()) | |
| reseat (param.get_pattern_ptr ()); | |
| } | |
| } // namespace AST | |
| } // namespace Rust |