pub trait MutWalker<C>: Sync + Send {
Show 669 methods
// Provided methods
fn walk_in_program(&mut self, program: &Program, context: &mut C) { ... }
fn walk_program(&mut self, program: &Program, context: &mut C) { ... }
fn walk_out_program(&mut self, program: &Program, context: &mut C) { ... }
fn walk_in_statement(&mut self, statement: &Statement, context: &mut C) { ... }
fn walk_statement(&mut self, statement: &Statement, context: &mut C) { ... }
fn walk_out_statement(&mut self, statement: &Statement, context: &mut C) { ... }
fn walk_in_opening_tag(&mut self, opening_tag: &OpeningTag, context: &mut C) { ... }
fn walk_opening_tag(&mut self, opening_tag: &OpeningTag, context: &mut C) { ... }
fn walk_out_opening_tag(
&mut self,
opening_tag: &OpeningTag,
context: &mut C,
) { ... }
fn walk_in_full_opening_tag(
&mut self,
full_opening_tag: &FullOpeningTag,
context: &mut C,
) { ... }
fn walk_full_opening_tag(
&mut self,
full_opening_tag: &FullOpeningTag,
context: &mut C,
) { ... }
fn walk_out_full_opening_tag(
&mut self,
full_opening_tag: &FullOpeningTag,
context: &mut C,
) { ... }
fn walk_in_short_opening_tag(
&mut self,
short_opening_tag: &ShortOpeningTag,
context: &mut C,
) { ... }
fn walk_short_opening_tag(
&mut self,
short_opening_tag: &ShortOpeningTag,
context: &mut C,
) { ... }
fn walk_out_short_opening_tag(
&mut self,
short_opening_tag: &ShortOpeningTag,
context: &mut C,
) { ... }
fn walk_in_echo_opening_tag(
&mut self,
echo_opening_tag: &EchoOpeningTag,
context: &mut C,
) { ... }
fn walk_echo_opening_tag(
&mut self,
echo_opening_tag: &EchoOpeningTag,
context: &mut C,
) { ... }
fn walk_out_echo_opening_tag(
&mut self,
echo_opening_tag: &EchoOpeningTag,
context: &mut C,
) { ... }
fn walk_in_closing_tag(&mut self, closing_tag: &ClosingTag, context: &mut C) { ... }
fn walk_closing_tag(&mut self, closing_tag: &ClosingTag, context: &mut C) { ... }
fn walk_out_closing_tag(
&mut self,
closing_tag: &ClosingTag,
context: &mut C,
) { ... }
fn walk_in_inline(&mut self, inline: &Inline, context: &mut C) { ... }
fn walk_inline(&mut self, inline: &Inline, context: &mut C) { ... }
fn walk_out_inline(&mut self, inline: &Inline, context: &mut C) { ... }
fn walk_in_namespace(&mut self, namespace: &Namespace, context: &mut C) { ... }
fn walk_namespace(&mut self, namespace: &Namespace, context: &mut C) { ... }
fn walk_out_namespace(&mut self, namespace: &Namespace, context: &mut C) { ... }
fn walk_in_namespace_body(
&mut self,
namespace_body: &NamespaceBody,
context: &mut C,
) { ... }
fn walk_namespace_body(
&mut self,
namespace_body: &NamespaceBody,
context: &mut C,
) { ... }
fn walk_out_namespace_body(
&mut self,
namespace_body: &NamespaceBody,
context: &mut C,
) { ... }
fn walk_in_namespace_implicit_body(
&mut self,
namespace_implicit_body: &NamespaceImplicitBody,
context: &mut C,
) { ... }
fn walk_namespace_implicit_body(
&mut self,
namespace_implicit_body: &NamespaceImplicitBody,
context: &mut C,
) { ... }
fn walk_out_namespace_implicit_body(
&mut self,
namespace_implicit_body: &NamespaceImplicitBody,
context: &mut C,
) { ... }
fn walk_in_terminator(&mut self, terminator: &Terminator, context: &mut C) { ... }
fn walk_terminator(&mut self, terminator: &Terminator, context: &mut C) { ... }
fn walk_out_terminator(&mut self, terminator: &Terminator, context: &mut C) { ... }
fn walk_in_use(&mut self, use: &Use, context: &mut C) { ... }
fn walk_use(&mut self, use: &Use, context: &mut C) { ... }
fn walk_out_use(&mut self, use: &Use, context: &mut C) { ... }
fn walk_in_use_items(&mut self, use_items: &UseItems, context: &mut C) { ... }
fn walk_use_items(&mut self, use_items: &UseItems, context: &mut C) { ... }
fn walk_out_use_items(&mut self, use_items: &UseItems, context: &mut C) { ... }
fn walk_in_use_item_sequence(
&mut self,
use_item_sequence: &UseItemSequence,
context: &mut C,
) { ... }
fn walk_use_item_sequence(
&mut self,
use_item_sequence: &UseItemSequence,
context: &mut C,
) { ... }
fn walk_out_use_item_sequence(
&mut self,
use_item_sequence: &UseItemSequence,
context: &mut C,
) { ... }
fn walk_in_use_item(&mut self, use_item: &UseItem, context: &mut C) { ... }
fn walk_use_item(&mut self, use_item: &UseItem, context: &mut C) { ... }
fn walk_out_use_item(&mut self, use_item: &UseItem, context: &mut C) { ... }
fn walk_in_use_item_alias(
&mut self,
use_item_alias: &UseItemAlias,
context: &mut C,
) { ... }
fn walk_use_item_alias(
&mut self,
use_item_alias: &UseItemAlias,
context: &mut C,
) { ... }
fn walk_out_use_item_alias(
&mut self,
use_item_alias: &UseItemAlias,
context: &mut C,
) { ... }
fn walk_in_typed_use_item_sequence(
&mut self,
typed_use_item_sequence: &TypedUseItemSequence,
context: &mut C,
) { ... }
fn walk_typed_use_item_sequence(
&mut self,
typed_use_item_sequence: &TypedUseItemSequence,
context: &mut C,
) { ... }
fn walk_out_typed_use_item_sequence(
&mut self,
typed_use_item_sequence: &TypedUseItemSequence,
context: &mut C,
) { ... }
fn walk_in_use_type(&mut self, use_type: &UseType, context: &mut C) { ... }
fn walk_use_type(&mut self, use_type: &UseType, context: &mut C) { ... }
fn walk_out_use_type(&mut self, use_type: &UseType, context: &mut C) { ... }
fn walk_in_typed_use_item_list(
&mut self,
typed_use_item_list: &TypedUseItemList,
context: &mut C,
) { ... }
fn walk_typed_use_item_list(
&mut self,
typed_use_item_list: &TypedUseItemList,
context: &mut C,
) { ... }
fn walk_out_typed_use_item_list(
&mut self,
typed_use_item_list: &TypedUseItemList,
context: &mut C,
) { ... }
fn walk_in_mixed_use_item_list(
&mut self,
mixed_use_item_list: &MixedUseItemList,
context: &mut C,
) { ... }
fn walk_mixed_use_item_list(
&mut self,
mixed_use_item_list: &MixedUseItemList,
context: &mut C,
) { ... }
fn walk_out_mixed_use_item_list(
&mut self,
mixed_use_item_list: &MixedUseItemList,
context: &mut C,
) { ... }
fn walk_in_maybe_typed_use_item(
&mut self,
maybe_typed_use_item: &MaybeTypedUseItem,
context: &mut C,
) { ... }
fn walk_maybe_typed_use_item(
&mut self,
maybe_typed_use_item: &MaybeTypedUseItem,
context: &mut C,
) { ... }
fn walk_out_maybe_typed_use_item(
&mut self,
maybe_typed_use_item: &MaybeTypedUseItem,
context: &mut C,
) { ... }
fn walk_in_attribute_list(
&mut self,
attribute_list: &AttributeList,
context: &mut C,
) { ... }
fn walk_attribute_list(
&mut self,
attribute_list: &AttributeList,
context: &mut C,
) { ... }
fn walk_out_attribute_list(
&mut self,
attribute_list: &AttributeList,
context: &mut C,
) { ... }
fn walk_in_attribute(&mut self, attribute: &Attribute, context: &mut C) { ... }
fn walk_attribute(&mut self, attribute: &Attribute, context: &mut C) { ... }
fn walk_out_attribute(&mut self, attribute: &Attribute, context: &mut C) { ... }
fn walk_in_argument_list(
&mut self,
argument_list: &ArgumentList,
context: &mut C,
) { ... }
fn walk_argument_list(
&mut self,
argument_list: &ArgumentList,
context: &mut C,
) { ... }
fn walk_out_argument_list(
&mut self,
argument_list: &ArgumentList,
context: &mut C,
) { ... }
fn walk_in_argument(&mut self, argument: &Argument, context: &mut C) { ... }
fn walk_argument(&mut self, argument: &Argument, context: &mut C) { ... }
fn walk_out_argument(&mut self, argument: &Argument, context: &mut C) { ... }
fn walk_in_positional_argument(
&mut self,
positional_argument: &PositionalArgument,
context: &mut C,
) { ... }
fn walk_positional_argument(
&mut self,
positional_argument: &PositionalArgument,
context: &mut C,
) { ... }
fn walk_out_positional_argument(
&mut self,
positional_argument: &PositionalArgument,
context: &mut C,
) { ... }
fn walk_in_named_argument(
&mut self,
named_argument: &NamedArgument,
context: &mut C,
) { ... }
fn walk_named_argument(
&mut self,
named_argument: &NamedArgument,
context: &mut C,
) { ... }
fn walk_out_named_argument(
&mut self,
named_argument: &NamedArgument,
context: &mut C,
) { ... }
fn walk_in_modifier(&mut self, modifier: &Modifier, context: &mut C) { ... }
fn walk_modifier(&mut self, modifier: &Modifier, context: &mut C) { ... }
fn walk_out_modifier(&mut self, modifier: &Modifier, context: &mut C) { ... }
fn walk_in_extends(&mut self, extends: &Extends, context: &mut C) { ... }
fn walk_extends(&mut self, extends: &Extends, context: &mut C) { ... }
fn walk_out_extends(&mut self, extends: &Extends, context: &mut C) { ... }
fn walk_in_implements(&mut self, implements: &Implements, context: &mut C) { ... }
fn walk_implements(&mut self, implements: &Implements, context: &mut C) { ... }
fn walk_out_implements(&mut self, implements: &Implements, context: &mut C) { ... }
fn walk_in_class(&mut self, class: &Class, context: &mut C) { ... }
fn walk_class(&mut self, class: &Class, context: &mut C) { ... }
fn walk_out_class(&mut self, class: &Class, context: &mut C) { ... }
fn walk_in_interface(&mut self, interface: &Interface, context: &mut C) { ... }
fn walk_interface(&mut self, interface: &Interface, context: &mut C) { ... }
fn walk_out_interface(&mut self, interface: &Interface, context: &mut C) { ... }
fn walk_in_trait(&mut self, trait: &Trait, context: &mut C) { ... }
fn walk_trait(&mut self, trait: &Trait, context: &mut C) { ... }
fn walk_out_trait(&mut self, trait: &Trait, context: &mut C) { ... }
fn walk_in_enum(&mut self, enum: &Enum, context: &mut C) { ... }
fn walk_enum(&mut self, enum: &Enum, context: &mut C) { ... }
fn walk_out_enum(&mut self, enum: &Enum, context: &mut C) { ... }
fn walk_in_enum_backing_type_hint(
&mut self,
enum_backing_type_hint: &EnumBackingTypeHint,
context: &mut C,
) { ... }
fn walk_enum_backing_type_hint(
&mut self,
enum_backing_type_hint: &EnumBackingTypeHint,
context: &mut C,
) { ... }
fn walk_out_enum_backing_type_hint(
&mut self,
enum_backing_type_hint: &EnumBackingTypeHint,
context: &mut C,
) { ... }
fn walk_in_class_like_member(
&mut self,
class_like_member: &ClassLikeMember,
context: &mut C,
) { ... }
fn walk_class_like_member(
&mut self,
class_like_member: &ClassLikeMember,
context: &mut C,
) { ... }
fn walk_out_class_like_member(
&mut self,
class_like_member: &ClassLikeMember,
context: &mut C,
) { ... }
fn walk_in_trait_use(&mut self, trait_use: &TraitUse, context: &mut C) { ... }
fn walk_trait_use(&mut self, trait_use: &TraitUse, context: &mut C) { ... }
fn walk_out_trait_use(&mut self, trait_use: &TraitUse, context: &mut C) { ... }
fn walk_in_trait_use_specification(
&mut self,
trait_use_specification: &TraitUseSpecification,
context: &mut C,
) { ... }
fn walk_trait_use_specification(
&mut self,
trait_use_specification: &TraitUseSpecification,
context: &mut C,
) { ... }
fn walk_out_trait_use_specification(
&mut self,
trait_use_specification: &TraitUseSpecification,
context: &mut C,
) { ... }
fn walk_in_trait_use_abstract_specification(
&mut self,
trait_use_abstract_specification: &TraitUseAbstractSpecification,
context: &mut C,
) { ... }
fn walk_trait_use_abstract_specification(
&mut self,
trait_use_abstract_specification: &TraitUseAbstractSpecification,
context: &mut C,
) { ... }
fn walk_out_trait_use_abstract_specification(
&mut self,
trait_use_abstract_specification: &TraitUseAbstractSpecification,
context: &mut C,
) { ... }
fn walk_in_trait_use_concrete_specification(
&mut self,
trait_use_concrete_specification: &TraitUseConcreteSpecification,
context: &mut C,
) { ... }
fn walk_trait_use_concrete_specification(
&mut self,
trait_use_concrete_specification: &TraitUseConcreteSpecification,
context: &mut C,
) { ... }
fn walk_out_trait_use_concrete_specification(
&mut self,
trait_use_concrete_specification: &TraitUseConcreteSpecification,
context: &mut C,
) { ... }
fn walk_in_trait_use_adaptation(
&mut self,
trait_use_adaptation: &TraitUseAdaptation,
context: &mut C,
) { ... }
fn walk_trait_use_adaptation(
&mut self,
trait_use_adaptation: &TraitUseAdaptation,
context: &mut C,
) { ... }
fn walk_out_trait_use_adaptation(
&mut self,
trait_use_adaptation: &TraitUseAdaptation,
context: &mut C,
) { ... }
fn walk_in_trait_use_precedence_adaptation(
&mut self,
trait_use_precedence_adaptation: &TraitUsePrecedenceAdaptation,
context: &mut C,
) { ... }
fn walk_trait_use_precedence_adaptation(
&mut self,
trait_use_precedence_adaptation: &TraitUsePrecedenceAdaptation,
context: &mut C,
) { ... }
fn walk_out_trait_use_precedence_adaptation(
&mut self,
trait_use_precedence_adaptation: &TraitUsePrecedenceAdaptation,
context: &mut C,
) { ... }
fn walk_in_trait_use_absolute_method_reference(
&mut self,
trait_use_absolute_method_reference: &TraitUseAbsoluteMethodReference,
context: &mut C,
) { ... }
fn walk_trait_use_absolute_method_reference(
&mut self,
trait_use_absolute_method_reference: &TraitUseAbsoluteMethodReference,
context: &mut C,
) { ... }
fn walk_out_trait_use_absolute_method_reference(
&mut self,
trait_use_absolute_method_reference: &TraitUseAbsoluteMethodReference,
context: &mut C,
) { ... }
fn walk_in_trait_use_alias_adaptation(
&mut self,
trait_use_alias_adaptation: &TraitUseAliasAdaptation,
context: &mut C,
) { ... }
fn walk_trait_use_alias_adaptation(
&mut self,
trait_use_alias_adaptation: &TraitUseAliasAdaptation,
context: &mut C,
) { ... }
fn walk_out_trait_use_alias_adaptation(
&mut self,
trait_use_alias_adaptation: &TraitUseAliasAdaptation,
context: &mut C,
) { ... }
fn walk_in_trait_use_method_reference(
&mut self,
trait_use_method_reference: &TraitUseMethodReference,
context: &mut C,
) { ... }
fn walk_trait_use_method_reference(
&mut self,
trait_use_method_reference: &TraitUseMethodReference,
context: &mut C,
) { ... }
fn walk_out_trait_use_method_reference(
&mut self,
trait_use_method_reference: &TraitUseMethodReference,
context: &mut C,
) { ... }
fn walk_in_class_like_constant(
&mut self,
class_like_constant: &ClassLikeConstant,
context: &mut C,
) { ... }
fn walk_class_like_constant(
&mut self,
class_like_constant: &ClassLikeConstant,
context: &mut C,
) { ... }
fn walk_out_class_like_constant(
&mut self,
class_like_constant: &ClassLikeConstant,
context: &mut C,
) { ... }
fn walk_in_class_like_constant_item(
&mut self,
class_like_constant_item: &ClassLikeConstantItem,
context: &mut C,
) { ... }
fn walk_class_like_constant_item(
&mut self,
class_like_constant_item: &ClassLikeConstantItem,
context: &mut C,
) { ... }
fn walk_out_class_like_constant_item(
&mut self,
class_like_constant_item: &ClassLikeConstantItem,
context: &mut C,
) { ... }
fn walk_in_property(&mut self, property: &Property, context: &mut C) { ... }
fn walk_property(&mut self, property: &Property, context: &mut C) { ... }
fn walk_out_property(&mut self, property: &Property, context: &mut C) { ... }
fn walk_in_plain_property(
&mut self,
plain_property: &PlainProperty,
context: &mut C,
) { ... }
fn walk_plain_property(
&mut self,
plain_property: &PlainProperty,
context: &mut C,
) { ... }
fn walk_out_plain_property(
&mut self,
plain_property: &PlainProperty,
context: &mut C,
) { ... }
fn walk_in_property_item(
&mut self,
property_item: &PropertyItem,
context: &mut C,
) { ... }
fn walk_property_item(
&mut self,
property_item: &PropertyItem,
context: &mut C,
) { ... }
fn walk_out_property_item(
&mut self,
property_item: &PropertyItem,
context: &mut C,
) { ... }
fn walk_in_property_abstract_item(
&mut self,
property_abstract_item: &PropertyAbstractItem,
context: &mut C,
) { ... }
fn walk_property_abstract_item(
&mut self,
property_abstract_item: &PropertyAbstractItem,
context: &mut C,
) { ... }
fn walk_out_property_abstract_item(
&mut self,
property_abstract_item: &PropertyAbstractItem,
context: &mut C,
) { ... }
fn walk_in_property_concrete_item(
&mut self,
property_concrete_item: &PropertyConcreteItem,
context: &mut C,
) { ... }
fn walk_property_concrete_item(
&mut self,
property_concrete_item: &PropertyConcreteItem,
context: &mut C,
) { ... }
fn walk_out_property_concrete_item(
&mut self,
property_concrete_item: &PropertyConcreteItem,
context: &mut C,
) { ... }
fn walk_in_hooked_property(
&mut self,
hooked_property: &HookedProperty,
context: &mut C,
) { ... }
fn walk_hooked_property(
&mut self,
hooked_property: &HookedProperty,
context: &mut C,
) { ... }
fn walk_out_hooked_property(
&mut self,
hooked_property: &HookedProperty,
context: &mut C,
) { ... }
fn walk_in_property_hook_list(
&mut self,
property_hook_list: &PropertyHookList,
context: &mut C,
) { ... }
fn walk_property_hook_list(
&mut self,
property_hook_list: &PropertyHookList,
context: &mut C,
) { ... }
fn walk_out_property_hook_list(
&mut self,
property_hook_list: &PropertyHookList,
context: &mut C,
) { ... }
fn walk_in_property_hook(
&mut self,
property_hook: &PropertyHook,
context: &mut C,
) { ... }
fn walk_property_hook(
&mut self,
property_hook: &PropertyHook,
context: &mut C,
) { ... }
fn walk_out_property_hook(
&mut self,
property_hook: &PropertyHook,
context: &mut C,
) { ... }
fn walk_in_property_hook_body(
&mut self,
property_hook_body: &PropertyHookBody,
context: &mut C,
) { ... }
fn walk_property_hook_body(
&mut self,
property_hook_body: &PropertyHookBody,
context: &mut C,
) { ... }
fn walk_out_property_hook_body(
&mut self,
property_hook_body: &PropertyHookBody,
context: &mut C,
) { ... }
fn walk_in_property_hook_abstract_body(
&mut self,
property_hook_abstract_body: &PropertyHookAbstractBody,
context: &mut C,
) { ... }
fn walk_property_hook_abstract_body(
&mut self,
property_hook_abstract_body: &PropertyHookAbstractBody,
context: &mut C,
) { ... }
fn walk_out_property_hook_abstract_body(
&mut self,
property_hook_abstract_body: &PropertyHookAbstractBody,
context: &mut C,
) { ... }
fn walk_in_property_hook_concrete_body(
&mut self,
property_hook_concrete_body: &PropertyHookConcreteBody,
context: &mut C,
) { ... }
fn walk_property_hook_concrete_body(
&mut self,
property_hook_concrete_body: &PropertyHookConcreteBody,
context: &mut C,
) { ... }
fn walk_out_property_hook_concrete_body(
&mut self,
property_hook_concrete_body: &PropertyHookConcreteBody,
context: &mut C,
) { ... }
fn walk_in_property_hook_concrete_expression_body(
&mut self,
property_hook_concrete_expression_body: &PropertyHookConcreteExpressionBody,
context: &mut C,
) { ... }
fn walk_property_hook_concrete_expression_body(
&mut self,
property_hook_concrete_expression_body: &PropertyHookConcreteExpressionBody,
context: &mut C,
) { ... }
fn walk_out_property_hook_concrete_expression_body(
&mut self,
property_hook_concrete_expression_body: &PropertyHookConcreteExpressionBody,
context: &mut C,
) { ... }
fn walk_in_function_like_parameter_list(
&mut self,
function_like_parameter_list: &FunctionLikeParameterList,
context: &mut C,
) { ... }
fn walk_function_like_parameter_list(
&mut self,
function_like_parameter_list: &FunctionLikeParameterList,
context: &mut C,
) { ... }
fn walk_out_function_like_parameter_list(
&mut self,
function_like_parameter_list: &FunctionLikeParameterList,
context: &mut C,
) { ... }
fn walk_in_function_like_parameter(
&mut self,
function_like_parameter: &FunctionLikeParameter,
context: &mut C,
) { ... }
fn walk_function_like_parameter(
&mut self,
function_like_parameter: &FunctionLikeParameter,
context: &mut C,
) { ... }
fn walk_out_function_like_parameter(
&mut self,
function_like_parameter: &FunctionLikeParameter,
context: &mut C,
) { ... }
fn walk_in_function_like_parameter_default_value(
&mut self,
function_like_parameter_default_value: &FunctionLikeParameterDefaultValue,
context: &mut C,
) { ... }
fn walk_function_like_parameter_default_value(
&mut self,
function_like_parameter_default_value: &FunctionLikeParameterDefaultValue,
context: &mut C,
) { ... }
fn walk_out_function_like_parameter_default_value(
&mut self,
function_like_parameter_default_value: &FunctionLikeParameterDefaultValue,
context: &mut C,
) { ... }
fn walk_in_enum_case(&mut self, enum_case: &EnumCase, context: &mut C) { ... }
fn walk_enum_case(&mut self, enum_case: &EnumCase, context: &mut C) { ... }
fn walk_out_enum_case(&mut self, enum_case: &EnumCase, context: &mut C) { ... }
fn walk_in_enum_case_item(
&mut self,
enum_case_item: &EnumCaseItem,
context: &mut C,
) { ... }
fn walk_enum_case_item(
&mut self,
enum_case_item: &EnumCaseItem,
context: &mut C,
) { ... }
fn walk_out_enum_case_item(
&mut self,
enum_case_item: &EnumCaseItem,
context: &mut C,
) { ... }
fn walk_in_enum_case_unit_item(
&mut self,
enum_case_unit_item: &EnumCaseUnitItem,
context: &mut C,
) { ... }
fn walk_enum_case_unit_item(
&mut self,
enum_case_unit_item: &EnumCaseUnitItem,
context: &mut C,
) { ... }
fn walk_out_enum_case_unit_item(
&mut self,
enum_case_unit_item: &EnumCaseUnitItem,
context: &mut C,
) { ... }
fn walk_in_enum_case_backed_item(
&mut self,
enum_case_backed_item: &EnumCaseBackedItem,
context: &mut C,
) { ... }
fn walk_enum_case_backed_item(
&mut self,
enum_case_backed_item: &EnumCaseBackedItem,
context: &mut C,
) { ... }
fn walk_out_enum_case_backed_item(
&mut self,
enum_case_backed_item: &EnumCaseBackedItem,
context: &mut C,
) { ... }
fn walk_in_method(&mut self, method: &Method, context: &mut C) { ... }
fn walk_method(&mut self, method: &Method, context: &mut C) { ... }
fn walk_out_method(&mut self, method: &Method, context: &mut C) { ... }
fn walk_in_method_body(&mut self, method_body: &MethodBody, context: &mut C) { ... }
fn walk_method_body(&mut self, method_body: &MethodBody, context: &mut C) { ... }
fn walk_out_method_body(
&mut self,
method_body: &MethodBody,
context: &mut C,
) { ... }
fn walk_in_method_abstract_body(
&mut self,
method_abstract_body: &MethodAbstractBody,
context: &mut C,
) { ... }
fn walk_method_abstract_body(
&mut self,
method_abstract_body: &MethodAbstractBody,
context: &mut C,
) { ... }
fn walk_out_method_abstract_body(
&mut self,
method_abstract_body: &MethodAbstractBody,
context: &mut C,
) { ... }
fn walk_in_function_like_return_type_hint(
&mut self,
function_like_return_type_hint: &FunctionLikeReturnTypeHint,
context: &mut C,
) { ... }
fn walk_function_like_return_type_hint(
&mut self,
function_like_return_type_hint: &FunctionLikeReturnTypeHint,
context: &mut C,
) { ... }
fn walk_out_function_like_return_type_hint(
&mut self,
function_like_return_type_hint: &FunctionLikeReturnTypeHint,
context: &mut C,
) { ... }
fn walk_in_block(&mut self, block: &Block, context: &mut C) { ... }
fn walk_block(&mut self, block: &Block, context: &mut C) { ... }
fn walk_out_block(&mut self, block: &Block, context: &mut C) { ... }
fn walk_in_constant(&mut self, constant: &Constant, context: &mut C) { ... }
fn walk_constant(&mut self, constant: &Constant, context: &mut C) { ... }
fn walk_out_constant(&mut self, constant: &Constant, context: &mut C) { ... }
fn walk_in_constant_item(
&mut self,
constant_item: &ConstantItem,
context: &mut C,
) { ... }
fn walk_constant_item(
&mut self,
constant_item: &ConstantItem,
context: &mut C,
) { ... }
fn walk_out_constant_item(
&mut self,
constant_item: &ConstantItem,
context: &mut C,
) { ... }
fn walk_in_function(&mut self, function: &Function, context: &mut C) { ... }
fn walk_function(&mut self, function: &Function, context: &mut C) { ... }
fn walk_out_function(&mut self, function: &Function, context: &mut C) { ... }
fn walk_in_declare(&mut self, declare: &Declare, context: &mut C) { ... }
fn walk_declare(&mut self, declare: &Declare, context: &mut C) { ... }
fn walk_out_declare(&mut self, declare: &Declare, context: &mut C) { ... }
fn walk_in_declare_item(
&mut self,
declare_item: &DeclareItem,
context: &mut C,
) { ... }
fn walk_declare_item(&mut self, declare_item: &DeclareItem, context: &mut C) { ... }
fn walk_out_declare_item(
&mut self,
declare_item: &DeclareItem,
context: &mut C,
) { ... }
fn walk_in_declare_body(
&mut self,
declare_body: &DeclareBody,
context: &mut C,
) { ... }
fn walk_declare_body(&mut self, declare_body: &DeclareBody, context: &mut C) { ... }
fn walk_out_declare_body(
&mut self,
declare_body: &DeclareBody,
context: &mut C,
) { ... }
fn walk_in_declare_colon_delimited_body(
&mut self,
declare_colon_delimited_body: &DeclareColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_declare_colon_delimited_body(
&mut self,
declare_colon_delimited_body: &DeclareColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_declare_colon_delimited_body(
&mut self,
declare_colon_delimited_body: &DeclareColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_goto(&mut self, goto: &Goto, context: &mut C) { ... }
fn walk_goto(&mut self, goto: &Goto, context: &mut C) { ... }
fn walk_out_goto(&mut self, goto: &Goto, context: &mut C) { ... }
fn walk_in_label(&mut self, label: &Label, context: &mut C) { ... }
fn walk_label(&mut self, label: &Label, context: &mut C) { ... }
fn walk_out_label(&mut self, label: &Label, context: &mut C) { ... }
fn walk_in_try(&mut self, try: &Try, context: &mut C) { ... }
fn walk_try(&mut self, try: &Try, context: &mut C) { ... }
fn walk_out_try(&mut self, try: &Try, context: &mut C) { ... }
fn walk_in_try_catch_clause(
&mut self,
try_catch_clause: &TryCatchClause,
context: &mut C,
) { ... }
fn walk_try_catch_clause(
&mut self,
try_catch_clause: &TryCatchClause,
context: &mut C,
) { ... }
fn walk_out_try_catch_clause(
&mut self,
try_catch_clause: &TryCatchClause,
context: &mut C,
) { ... }
fn walk_in_try_finally_clause(
&mut self,
try_finally_clause: &TryFinallyClause,
context: &mut C,
) { ... }
fn walk_try_finally_clause(
&mut self,
try_finally_clause: &TryFinallyClause,
context: &mut C,
) { ... }
fn walk_out_try_finally_clause(
&mut self,
try_finally_clause: &TryFinallyClause,
context: &mut C,
) { ... }
fn walk_in_foreach(&mut self, foreach: &Foreach, context: &mut C) { ... }
fn walk_foreach(&mut self, foreach: &Foreach, context: &mut C) { ... }
fn walk_out_foreach(&mut self, foreach: &Foreach, context: &mut C) { ... }
fn walk_in_foreach_target(
&mut self,
foreach_target: &ForeachTarget,
context: &mut C,
) { ... }
fn walk_foreach_target(
&mut self,
foreach_target: &ForeachTarget,
context: &mut C,
) { ... }
fn walk_out_foreach_target(
&mut self,
foreach_target: &ForeachTarget,
context: &mut C,
) { ... }
fn walk_in_foreach_value_target(
&mut self,
foreach_value_target: &ForeachValueTarget,
context: &mut C,
) { ... }
fn walk_foreach_value_target(
&mut self,
foreach_value_target: &ForeachValueTarget,
context: &mut C,
) { ... }
fn walk_out_foreach_value_target(
&mut self,
foreach_value_target: &ForeachValueTarget,
context: &mut C,
) { ... }
fn walk_in_foreach_key_value_target(
&mut self,
foreach_key_value_target: &ForeachKeyValueTarget,
context: &mut C,
) { ... }
fn walk_foreach_key_value_target(
&mut self,
foreach_key_value_target: &ForeachKeyValueTarget,
context: &mut C,
) { ... }
fn walk_out_foreach_key_value_target(
&mut self,
foreach_key_value_target: &ForeachKeyValueTarget,
context: &mut C,
) { ... }
fn walk_in_foreach_body(
&mut self,
foreach_body: &ForeachBody,
context: &mut C,
) { ... }
fn walk_foreach_body(&mut self, foreach_body: &ForeachBody, context: &mut C) { ... }
fn walk_out_foreach_body(
&mut self,
foreach_body: &ForeachBody,
context: &mut C,
) { ... }
fn walk_in_foreach_colon_delimited_body(
&mut self,
foreach_colon_delimited_body: &ForeachColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_foreach_colon_delimited_body(
&mut self,
foreach_colon_delimited_body: &ForeachColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_foreach_colon_delimited_body(
&mut self,
foreach_colon_delimited_body: &ForeachColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_for(&mut self, for: &For, context: &mut C) { ... }
fn walk_for(&mut self, for: &For, context: &mut C) { ... }
fn walk_out_for(&mut self, for: &For, context: &mut C) { ... }
fn walk_in_for_body(&mut self, for_body: &ForBody, context: &mut C) { ... }
fn walk_for_body(&mut self, for_body: &ForBody, context: &mut C) { ... }
fn walk_out_for_body(&mut self, for_body: &ForBody, context: &mut C) { ... }
fn walk_in_for_colon_delimited_body(
&mut self,
for_colon_delimited_body: &ForColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_for_colon_delimited_body(
&mut self,
for_colon_delimited_body: &ForColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_for_colon_delimited_body(
&mut self,
for_colon_delimited_body: &ForColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_while(&mut self, while: &While, context: &mut C) { ... }
fn walk_while(&mut self, while: &While, context: &mut C) { ... }
fn walk_out_while(&mut self, while: &While, context: &mut C) { ... }
fn walk_in_while_body(&mut self, while_body: &WhileBody, context: &mut C) { ... }
fn walk_while_body(&mut self, while_body: &WhileBody, context: &mut C) { ... }
fn walk_out_while_body(&mut self, while_body: &WhileBody, context: &mut C) { ... }
fn walk_in_while_colon_delimited_body(
&mut self,
while_colon_delimited_body: &WhileColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_while_colon_delimited_body(
&mut self,
while_colon_delimited_body: &WhileColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_while_colon_delimited_body(
&mut self,
while_colon_delimited_body: &WhileColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_do_while(&mut self, do_while: &DoWhile, context: &mut C) { ... }
fn walk_do_while(&mut self, do_while: &DoWhile, context: &mut C) { ... }
fn walk_out_do_while(&mut self, do_while: &DoWhile, context: &mut C) { ... }
fn walk_in_continue(&mut self, continue: &Continue, context: &mut C) { ... }
fn walk_continue(&mut self, continue: &Continue, context: &mut C) { ... }
fn walk_out_continue(&mut self, continue: &Continue, context: &mut C) { ... }
fn walk_in_break(&mut self, break: &Break, context: &mut C) { ... }
fn walk_break(&mut self, break: &Break, context: &mut C) { ... }
fn walk_out_break(&mut self, break: &Break, context: &mut C) { ... }
fn walk_in_switch(&mut self, switch: &Switch, context: &mut C) { ... }
fn walk_switch(&mut self, switch: &Switch, context: &mut C) { ... }
fn walk_out_switch(&mut self, switch: &Switch, context: &mut C) { ... }
fn walk_in_switch_body(&mut self, switch_body: &SwitchBody, context: &mut C) { ... }
fn walk_switch_body(&mut self, switch_body: &SwitchBody, context: &mut C) { ... }
fn walk_out_switch_body(
&mut self,
switch_body: &SwitchBody,
context: &mut C,
) { ... }
fn walk_in_switch_brace_delimited_body(
&mut self,
switch_brace_delimited_body: &SwitchBraceDelimitedBody,
context: &mut C,
) { ... }
fn walk_switch_brace_delimited_body(
&mut self,
switch_brace_delimited_body: &SwitchBraceDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_switch_brace_delimited_body(
&mut self,
switch_brace_delimited_body: &SwitchBraceDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_switch_colon_delimited_body(
&mut self,
switch_colon_delimited_body: &SwitchColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_switch_colon_delimited_body(
&mut self,
switch_colon_delimited_body: &SwitchColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_switch_colon_delimited_body(
&mut self,
switch_colon_delimited_body: &SwitchColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_switch_case(&mut self, switch_case: &SwitchCase, context: &mut C) { ... }
fn walk_switch_case(&mut self, switch_case: &SwitchCase, context: &mut C) { ... }
fn walk_out_switch_case(
&mut self,
switch_case: &SwitchCase,
context: &mut C,
) { ... }
fn walk_in_switch_expression_case(
&mut self,
switch_expression_case: &SwitchExpressionCase,
context: &mut C,
) { ... }
fn walk_switch_expression_case(
&mut self,
switch_expression_case: &SwitchExpressionCase,
context: &mut C,
) { ... }
fn walk_out_switch_expression_case(
&mut self,
switch_expression_case: &SwitchExpressionCase,
context: &mut C,
) { ... }
fn walk_in_switch_default_case(
&mut self,
switch_default_case: &SwitchDefaultCase,
context: &mut C,
) { ... }
fn walk_switch_default_case(
&mut self,
switch_default_case: &SwitchDefaultCase,
context: &mut C,
) { ... }
fn walk_out_switch_default_case(
&mut self,
switch_default_case: &SwitchDefaultCase,
context: &mut C,
) { ... }
fn walk_in_switch_case_separator(
&mut self,
switch_case_separator: &SwitchCaseSeparator,
context: &mut C,
) { ... }
fn walk_switch_case_separator(
&mut self,
switch_case_separator: &SwitchCaseSeparator,
context: &mut C,
) { ... }
fn walk_out_switch_case_separator(
&mut self,
switch_case_separator: &SwitchCaseSeparator,
context: &mut C,
) { ... }
fn walk_in_if(&mut self, if: &If, context: &mut C) { ... }
fn walk_if(&mut self, if: &If, context: &mut C) { ... }
fn walk_out_if(&mut self, if: &If, context: &mut C) { ... }
fn walk_in_if_body(&mut self, if_body: &IfBody, context: &mut C) { ... }
fn walk_if_body(&mut self, if_body: &IfBody, context: &mut C) { ... }
fn walk_out_if_body(&mut self, if_body: &IfBody, context: &mut C) { ... }
fn walk_in_if_statement_body(
&mut self,
if_statement_body: &IfStatementBody,
context: &mut C,
) { ... }
fn walk_if_statement_body(
&mut self,
if_statement_body: &IfStatementBody,
context: &mut C,
) { ... }
fn walk_out_if_statement_body(
&mut self,
if_statement_body: &IfStatementBody,
context: &mut C,
) { ... }
fn walk_in_if_statement_body_else_if_clause(
&mut self,
if_statement_body_else_if_clause: &IfStatementBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_if_statement_body_else_if_clause(
&mut self,
if_statement_body_else_if_clause: &IfStatementBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_out_if_statement_body_else_if_clause(
&mut self,
if_statement_body_else_if_clause: &IfStatementBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_in_if_statement_body_else_clause(
&mut self,
if_statement_body_else_clause: &IfStatementBodyElseClause,
context: &mut C,
) { ... }
fn walk_if_statement_body_else_clause(
&mut self,
if_statement_body_else_clause: &IfStatementBodyElseClause,
context: &mut C,
) { ... }
fn walk_out_if_statement_body_else_clause(
&mut self,
if_statement_body_else_clause: &IfStatementBodyElseClause,
context: &mut C,
) { ... }
fn walk_in_if_colon_delimited_body(
&mut self,
if_colon_delimited_body: &IfColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_if_colon_delimited_body(
&mut self,
if_colon_delimited_body: &IfColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_out_if_colon_delimited_body(
&mut self,
if_colon_delimited_body: &IfColonDelimitedBody,
context: &mut C,
) { ... }
fn walk_in_if_colon_delimited_body_else_if_clause(
&mut self,
if_colon_delimited_body_else_if_clause: &IfColonDelimitedBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_if_colon_delimited_body_else_if_clause(
&mut self,
if_colon_delimited_body_else_if_clause: &IfColonDelimitedBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_out_if_colon_delimited_body_else_if_clause(
&mut self,
if_colon_delimited_body_else_if_clause: &IfColonDelimitedBodyElseIfClause,
context: &mut C,
) { ... }
fn walk_in_if_colon_delimited_body_else_clause(
&mut self,
if_colon_delimited_body_else_clause: &IfColonDelimitedBodyElseClause,
context: &mut C,
) { ... }
fn walk_if_colon_delimited_body_else_clause(
&mut self,
if_colon_delimited_body_else_clause: &IfColonDelimitedBodyElseClause,
context: &mut C,
) { ... }
fn walk_out_if_colon_delimited_body_else_clause(
&mut self,
if_colon_delimited_body_else_clause: &IfColonDelimitedBodyElseClause,
context: &mut C,
) { ... }
fn walk_in_return(&mut self, return: &Return, context: &mut C) { ... }
fn walk_return(&mut self, return: &Return, context: &mut C) { ... }
fn walk_out_return(&mut self, return: &Return, context: &mut C) { ... }
fn walk_in_statement_expression(
&mut self,
statement_expression: &ExpressionStatement,
context: &mut C,
) { ... }
fn walk_statement_expression(
&mut self,
statement_expression: &ExpressionStatement,
context: &mut C,
) { ... }
fn walk_out_statement_expression(
&mut self,
statement_expression: &ExpressionStatement,
context: &mut C,
) { ... }
fn walk_in_echo(&mut self, echo: &Echo, context: &mut C) { ... }
fn walk_echo(&mut self, echo: &Echo, context: &mut C) { ... }
fn walk_out_echo(&mut self, echo: &Echo, context: &mut C) { ... }
fn walk_in_global(&mut self, global: &Global, context: &mut C) { ... }
fn walk_global(&mut self, global: &Global, context: &mut C) { ... }
fn walk_out_global(&mut self, global: &Global, context: &mut C) { ... }
fn walk_in_static(&mut self, static: &Static, context: &mut C) { ... }
fn walk_static(&mut self, static: &Static, context: &mut C) { ... }
fn walk_out_static(&mut self, static: &Static, context: &mut C) { ... }
fn walk_in_static_item(&mut self, static_item: &StaticItem, context: &mut C) { ... }
fn walk_static_item(&mut self, static_item: &StaticItem, context: &mut C) { ... }
fn walk_out_static_item(
&mut self,
static_item: &StaticItem,
context: &mut C,
) { ... }
fn walk_in_static_abstract_item(
&mut self,
static_abstract_item: &StaticAbstractItem,
context: &mut C,
) { ... }
fn walk_static_abstract_item(
&mut self,
static_abstract_item: &StaticAbstractItem,
context: &mut C,
) { ... }
fn walk_out_static_abstract_item(
&mut self,
static_abstract_item: &StaticAbstractItem,
context: &mut C,
) { ... }
fn walk_in_static_concrete_item(
&mut self,
static_concrete_item: &StaticConcreteItem,
context: &mut C,
) { ... }
fn walk_static_concrete_item(
&mut self,
static_concrete_item: &StaticConcreteItem,
context: &mut C,
) { ... }
fn walk_out_static_concrete_item(
&mut self,
static_concrete_item: &StaticConcreteItem,
context: &mut C,
) { ... }
fn walk_in_halt_compiler(
&mut self,
halt_compiler: &HaltCompiler,
context: &mut C,
) { ... }
fn walk_halt_compiler(
&mut self,
halt_compiler: &HaltCompiler,
context: &mut C,
) { ... }
fn walk_out_halt_compiler(
&mut self,
halt_compiler: &HaltCompiler,
context: &mut C,
) { ... }
fn walk_in_unset(&mut self, unset: &Unset, context: &mut C) { ... }
fn walk_unset(&mut self, unset: &Unset, context: &mut C) { ... }
fn walk_out_unset(&mut self, unset: &Unset, context: &mut C) { ... }
fn walk_in_expression(&mut self, expression: &Expression, context: &mut C) { ... }
fn walk_expression(&mut self, expression: &Expression, context: &mut C) { ... }
fn walk_out_expression(&mut self, expression: &Expression, context: &mut C) { ... }
fn walk_in_binary(&mut self, binary: &Binary, context: &mut C) { ... }
fn walk_binary(&mut self, binary: &Binary, context: &mut C) { ... }
fn walk_out_binary(&mut self, binary: &Binary, context: &mut C) { ... }
fn walk_in_binary_operator(
&mut self,
binary_operator: &BinaryOperator,
context: &mut C,
) { ... }
fn walk_binary_operator(
&mut self,
binary_operator: &BinaryOperator,
context: &mut C,
) { ... }
fn walk_out_binary_operator(
&mut self,
binary_operator: &BinaryOperator,
context: &mut C,
) { ... }
fn walk_in_unary_prefix(
&mut self,
unary_prefix: &UnaryPrefix,
context: &mut C,
) { ... }
fn walk_unary_prefix(&mut self, unary_prefix: &UnaryPrefix, context: &mut C) { ... }
fn walk_out_unary_prefix(
&mut self,
unary_prefix: &UnaryPrefix,
context: &mut C,
) { ... }
fn walk_in_unary_prefix_operator(
&mut self,
unary_prefix_operator: &UnaryPrefixOperator,
context: &mut C,
) { ... }
fn walk_unary_prefix_operator(
&mut self,
unary_prefix_operator: &UnaryPrefixOperator,
context: &mut C,
) { ... }
fn walk_out_unary_prefix_operator(
&mut self,
unary_prefix_operator: &UnaryPrefixOperator,
context: &mut C,
) { ... }
fn walk_in_unary_postfix(
&mut self,
unary_postfix: &UnaryPostfix,
context: &mut C,
) { ... }
fn walk_unary_postfix(
&mut self,
unary_postfix: &UnaryPostfix,
context: &mut C,
) { ... }
fn walk_out_unary_postfix(
&mut self,
unary_postfix: &UnaryPostfix,
context: &mut C,
) { ... }
fn walk_in_unary_postfix_operator(
&mut self,
unary_postfix_operator: &UnaryPostfixOperator,
context: &mut C,
) { ... }
fn walk_unary_postfix_operator(
&mut self,
unary_postfix_operator: &UnaryPostfixOperator,
context: &mut C,
) { ... }
fn walk_out_unary_postfix_operator(
&mut self,
unary_postfix_operator: &UnaryPostfixOperator,
context: &mut C,
) { ... }
fn walk_in_parenthesized(
&mut self,
parenthesized: &Parenthesized,
context: &mut C,
) { ... }
fn walk_parenthesized(
&mut self,
parenthesized: &Parenthesized,
context: &mut C,
) { ... }
fn walk_out_parenthesized(
&mut self,
parenthesized: &Parenthesized,
context: &mut C,
) { ... }
fn walk_in_literal_expression(
&mut self,
literal_expression: &Literal,
context: &mut C,
) { ... }
fn walk_literal_expression(
&mut self,
literal_expression: &Literal,
context: &mut C,
) { ... }
fn walk_out_literal_expression(
&mut self,
literal_expression: &Literal,
context: &mut C,
) { ... }
fn walk_in_literal_string(
&mut self,
literal_string: &LiteralString,
context: &mut C,
) { ... }
fn walk_literal_string(
&mut self,
literal_string: &LiteralString,
context: &mut C,
) { ... }
fn walk_out_literal_string(
&mut self,
literal_string: &LiteralString,
context: &mut C,
) { ... }
fn walk_in_literal_integer(
&mut self,
literal_integer: &LiteralInteger,
context: &mut C,
) { ... }
fn walk_literal_integer(
&mut self,
literal_integer: &LiteralInteger,
context: &mut C,
) { ... }
fn walk_out_literal_integer(
&mut self,
literal_integer: &LiteralInteger,
context: &mut C,
) { ... }
fn walk_in_literal_float(
&mut self,
literal_float: &LiteralFloat,
context: &mut C,
) { ... }
fn walk_literal_float(
&mut self,
literal_float: &LiteralFloat,
context: &mut C,
) { ... }
fn walk_out_literal_float(
&mut self,
literal_float: &LiteralFloat,
context: &mut C,
) { ... }
fn walk_in_true_keyword(&mut self, true_keyword: &Keyword, context: &mut C) { ... }
fn walk_true_keyword(&mut self, true_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_true_keyword(&mut self, true_keyword: &Keyword, context: &mut C) { ... }
fn walk_in_false_keyword(
&mut self,
false_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_false_keyword(&mut self, false_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_false_keyword(
&mut self,
false_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_in_null_keyword(&mut self, null_keyword: &Keyword, context: &mut C) { ... }
fn walk_null_keyword(&mut self, null_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_null_keyword(&mut self, null_keyword: &Keyword, context: &mut C) { ... }
fn walk_in_composite_string(
&mut self,
composite_string: &CompositeString,
context: &mut C,
) { ... }
fn walk_composite_string(
&mut self,
composite_string: &CompositeString,
context: &mut C,
) { ... }
fn walk_out_composite_string(
&mut self,
composite_string: &CompositeString,
context: &mut C,
) { ... }
fn walk_in_shell_execute_string(
&mut self,
shell_execute_string: &ShellExecuteString,
context: &mut C,
) { ... }
fn walk_shell_execute_string(
&mut self,
shell_execute_string: &ShellExecuteString,
context: &mut C,
) { ... }
fn walk_out_shell_execute_string(
&mut self,
shell_execute_string: &ShellExecuteString,
context: &mut C,
) { ... }
fn walk_in_interpolated_string(
&mut self,
interpolated_string: &InterpolatedString,
context: &mut C,
) { ... }
fn walk_interpolated_string(
&mut self,
interpolated_string: &InterpolatedString,
context: &mut C,
) { ... }
fn walk_out_interpolated_string(
&mut self,
interpolated_string: &InterpolatedString,
context: &mut C,
) { ... }
fn walk_in_document_string(
&mut self,
document_string: &DocumentString,
context: &mut C,
) { ... }
fn walk_document_string(
&mut self,
document_string: &DocumentString,
context: &mut C,
) { ... }
fn walk_out_document_string(
&mut self,
document_string: &DocumentString,
context: &mut C,
) { ... }
fn walk_in_string_part(&mut self, string_part: &StringPart, context: &mut C) { ... }
fn walk_string_part(&mut self, string_part: &StringPart, context: &mut C) { ... }
fn walk_out_string_part(
&mut self,
string_part: &StringPart,
context: &mut C,
) { ... }
fn walk_in_literal_string_part(
&mut self,
literal_string_part: &LiteralStringPart,
context: &mut C,
) { ... }
fn walk_literal_string_part(
&mut self,
literal_string_part: &LiteralStringPart,
context: &mut C,
) { ... }
fn walk_out_literal_string_part(
&mut self,
literal_string_part: &LiteralStringPart,
context: &mut C,
) { ... }
fn walk_in_braced_expression_string_part(
&mut self,
braced_expression_string_part: &BracedExpressionStringPart,
context: &mut C,
) { ... }
fn walk_braced_expression_string_part(
&mut self,
braced_expression_string_part: &BracedExpressionStringPart,
context: &mut C,
) { ... }
fn walk_out_braced_expression_string_part(
&mut self,
braced_expression_string_part: &BracedExpressionStringPart,
context: &mut C,
) { ... }
fn walk_in_assignment(&mut self, assignment: &Assignment, context: &mut C) { ... }
fn walk_assignment(&mut self, assignment: &Assignment, context: &mut C) { ... }
fn walk_out_assignment(&mut self, assignment: &Assignment, context: &mut C) { ... }
fn walk_in_assignment_operator(
&mut self,
assignment_operator: &AssignmentOperator,
context: &mut C,
) { ... }
fn walk_assignment_operator(
&mut self,
assignment_operator: &AssignmentOperator,
context: &mut C,
) { ... }
fn walk_out_assignment_operator(
&mut self,
assignment_operator: &AssignmentOperator,
context: &mut C,
) { ... }
fn walk_in_conditional(
&mut self,
conditional: &Conditional,
context: &mut C,
) { ... }
fn walk_conditional(&mut self, conditional: &Conditional, context: &mut C) { ... }
fn walk_out_conditional(
&mut self,
conditional: &Conditional,
context: &mut C,
) { ... }
fn walk_in_array(&mut self, array: &Array, context: &mut C) { ... }
fn walk_array(&mut self, array: &Array, context: &mut C) { ... }
fn walk_out_array(&mut self, array: &Array, context: &mut C) { ... }
fn walk_in_array_element(
&mut self,
array_element: &ArrayElement,
context: &mut C,
) { ... }
fn walk_array_element(
&mut self,
array_element: &ArrayElement,
context: &mut C,
) { ... }
fn walk_out_array_element(
&mut self,
array_element: &ArrayElement,
context: &mut C,
) { ... }
fn walk_in_key_value_array_element(
&mut self,
key_value_array_element: &KeyValueArrayElement,
context: &mut C,
) { ... }
fn walk_key_value_array_element(
&mut self,
key_value_array_element: &KeyValueArrayElement,
context: &mut C,
) { ... }
fn walk_out_key_value_array_element(
&mut self,
key_value_array_element: &KeyValueArrayElement,
context: &mut C,
) { ... }
fn walk_in_value_array_element(
&mut self,
value_array_element: &ValueArrayElement,
context: &mut C,
) { ... }
fn walk_value_array_element(
&mut self,
value_array_element: &ValueArrayElement,
context: &mut C,
) { ... }
fn walk_out_value_array_element(
&mut self,
value_array_element: &ValueArrayElement,
context: &mut C,
) { ... }
fn walk_in_variadic_array_element(
&mut self,
variadic_array_element: &VariadicArrayElement,
context: &mut C,
) { ... }
fn walk_variadic_array_element(
&mut self,
variadic_array_element: &VariadicArrayElement,
context: &mut C,
) { ... }
fn walk_out_variadic_array_element(
&mut self,
variadic_array_element: &VariadicArrayElement,
context: &mut C,
) { ... }
fn walk_in_missing_array_element(
&mut self,
missing_array_element: &MissingArrayElement,
context: &mut C,
) { ... }
fn walk_missing_array_element(
&mut self,
missing_array_element: &MissingArrayElement,
context: &mut C,
) { ... }
fn walk_out_missing_array_element(
&mut self,
missing_array_element: &MissingArrayElement,
context: &mut C,
) { ... }
fn walk_in_legacy_array(
&mut self,
legacy_array: &LegacyArray,
context: &mut C,
) { ... }
fn walk_legacy_array(&mut self, legacy_array: &LegacyArray, context: &mut C) { ... }
fn walk_out_legacy_array(
&mut self,
legacy_array: &LegacyArray,
context: &mut C,
) { ... }
fn walk_in_list(&mut self, list: &List, context: &mut C) { ... }
fn walk_list(&mut self, list: &List, context: &mut C) { ... }
fn walk_out_list(&mut self, list: &List, context: &mut C) { ... }
fn walk_in_array_access(
&mut self,
array_access: &ArrayAccess,
context: &mut C,
) { ... }
fn walk_array_access(&mut self, array_access: &ArrayAccess, context: &mut C) { ... }
fn walk_out_array_access(
&mut self,
array_access: &ArrayAccess,
context: &mut C,
) { ... }
fn walk_in_array_append(
&mut self,
array_append: &ArrayAppend,
context: &mut C,
) { ... }
fn walk_array_append(&mut self, array_append: &ArrayAppend, context: &mut C) { ... }
fn walk_out_array_append(
&mut self,
array_append: &ArrayAppend,
context: &mut C,
) { ... }
fn walk_in_anonymous_class(
&mut self,
anonymous_class: &AnonymousClass,
context: &mut C,
) { ... }
fn walk_anonymous_class(
&mut self,
anonymous_class: &AnonymousClass,
context: &mut C,
) { ... }
fn walk_out_anonymous_class(
&mut self,
anonymous_class: &AnonymousClass,
context: &mut C,
) { ... }
fn walk_in_closure(&mut self, closure: &Closure, context: &mut C) { ... }
fn walk_closure(&mut self, closure: &Closure, context: &mut C) { ... }
fn walk_out_closure(&mut self, closure: &Closure, context: &mut C) { ... }
fn walk_in_closure_use_clause(
&mut self,
closure_use_clause: &ClosureUseClause,
context: &mut C,
) { ... }
fn walk_closure_use_clause(
&mut self,
closure_use_clause: &ClosureUseClause,
context: &mut C,
) { ... }
fn walk_out_closure_use_clause(
&mut self,
closure_use_clause: &ClosureUseClause,
context: &mut C,
) { ... }
fn walk_in_closure_use_clause_variable(
&mut self,
closure_use_clause_variable: &ClosureUseClauseVariable,
context: &mut C,
) { ... }
fn walk_closure_use_clause_variable(
&mut self,
closure_use_clause_variable: &ClosureUseClauseVariable,
context: &mut C,
) { ... }
fn walk_out_closure_use_clause_variable(
&mut self,
closure_use_clause_variable: &ClosureUseClauseVariable,
context: &mut C,
) { ... }
fn walk_in_arrow_function(
&mut self,
arrow_function: &ArrowFunction,
context: &mut C,
) { ... }
fn walk_arrow_function(
&mut self,
arrow_function: &ArrowFunction,
context: &mut C,
) { ... }
fn walk_out_arrow_function(
&mut self,
arrow_function: &ArrowFunction,
context: &mut C,
) { ... }
fn walk_in_variable(&mut self, variable: &Variable, context: &mut C) { ... }
fn walk_variable(&mut self, variable: &Variable, context: &mut C) { ... }
fn walk_out_variable(&mut self, variable: &Variable, context: &mut C) { ... }
fn walk_in_direct_variable(
&mut self,
direct_variable: &DirectVariable,
context: &mut C,
) { ... }
fn walk_direct_variable(
&mut self,
direct_variable: &DirectVariable,
context: &mut C,
) { ... }
fn walk_out_direct_variable(
&mut self,
direct_variable: &DirectVariable,
context: &mut C,
) { ... }
fn walk_in_indirect_variable(
&mut self,
indirect_variable: &IndirectVariable,
context: &mut C,
) { ... }
fn walk_indirect_variable(
&mut self,
indirect_variable: &IndirectVariable,
context: &mut C,
) { ... }
fn walk_out_indirect_variable(
&mut self,
indirect_variable: &IndirectVariable,
context: &mut C,
) { ... }
fn walk_in_nested_variable(
&mut self,
nested_variable: &NestedVariable,
context: &mut C,
) { ... }
fn walk_nested_variable(
&mut self,
nested_variable: &NestedVariable,
context: &mut C,
) { ... }
fn walk_out_nested_variable(
&mut self,
nested_variable: &NestedVariable,
context: &mut C,
) { ... }
fn walk_in_identifier(&mut self, identifier: &Identifier, context: &mut C) { ... }
fn walk_identifier(&mut self, identifier: &Identifier, context: &mut C) { ... }
fn walk_out_identifier(&mut self, identifier: &Identifier, context: &mut C) { ... }
fn walk_in_local_identifier(
&mut self,
local_identifier: &LocalIdentifier,
context: &mut C,
) { ... }
fn walk_local_identifier(
&mut self,
local_identifier: &LocalIdentifier,
context: &mut C,
) { ... }
fn walk_out_local_identifier(
&mut self,
local_identifier: &LocalIdentifier,
context: &mut C,
) { ... }
fn walk_in_qualified_identifier(
&mut self,
qualified_identifier: &QualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_qualified_identifier(
&mut self,
qualified_identifier: &QualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_out_qualified_identifier(
&mut self,
qualified_identifier: &QualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_in_fully_qualified_identifier(
&mut self,
fully_qualified_identifier: &FullyQualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_fully_qualified_identifier(
&mut self,
fully_qualified_identifier: &FullyQualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_out_fully_qualified_identifier(
&mut self,
fully_qualified_identifier: &FullyQualifiedIdentifier,
context: &mut C,
) { ... }
fn walk_in_match(&mut self, match: &Match, context: &mut C) { ... }
fn walk_match(&mut self, match: &Match, context: &mut C) { ... }
fn walk_out_match(&mut self, match: &Match, context: &mut C) { ... }
fn walk_in_match_arm(&mut self, match_arm: &MatchArm, context: &mut C) { ... }
fn walk_match_arm(&mut self, match_arm: &MatchArm, context: &mut C) { ... }
fn walk_out_match_arm(&mut self, match_arm: &MatchArm, context: &mut C) { ... }
fn walk_in_match_expression_arm(
&mut self,
match_expression_arm: &MatchExpressionArm,
context: &mut C,
) { ... }
fn walk_match_expression_arm(
&mut self,
match_expression_arm: &MatchExpressionArm,
context: &mut C,
) { ... }
fn walk_out_match_expression_arm(
&mut self,
match_expression_arm: &MatchExpressionArm,
context: &mut C,
) { ... }
fn walk_in_match_default_arm(
&mut self,
match_default_arm: &MatchDefaultArm,
context: &mut C,
) { ... }
fn walk_match_default_arm(
&mut self,
match_default_arm: &MatchDefaultArm,
context: &mut C,
) { ... }
fn walk_out_match_default_arm(
&mut self,
match_default_arm: &MatchDefaultArm,
context: &mut C,
) { ... }
fn walk_in_yield(&mut self, yield: &Yield, context: &mut C) { ... }
fn walk_yield(&mut self, yield: &Yield, context: &mut C) { ... }
fn walk_out_yield(&mut self, yield: &Yield, context: &mut C) { ... }
fn walk_in_yield_value(&mut self, yield_value: &YieldValue, context: &mut C) { ... }
fn walk_yield_value(&mut self, yield_value: &YieldValue, context: &mut C) { ... }
fn walk_out_yield_value(
&mut self,
yield_value: &YieldValue,
context: &mut C,
) { ... }
fn walk_in_yield_pair(&mut self, yield_pair: &YieldPair, context: &mut C) { ... }
fn walk_yield_pair(&mut self, yield_pair: &YieldPair, context: &mut C) { ... }
fn walk_out_yield_pair(&mut self, yield_pair: &YieldPair, context: &mut C) { ... }
fn walk_in_yield_from(&mut self, yield_from: &YieldFrom, context: &mut C) { ... }
fn walk_yield_from(&mut self, yield_from: &YieldFrom, context: &mut C) { ... }
fn walk_out_yield_from(&mut self, yield_from: &YieldFrom, context: &mut C) { ... }
fn walk_in_construct(&mut self, construct: &Construct, context: &mut C) { ... }
fn walk_construct(&mut self, construct: &Construct, context: &mut C) { ... }
fn walk_out_construct(&mut self, construct: &Construct, context: &mut C) { ... }
fn walk_in_isset_construct(
&mut self,
isset_construct: &IssetConstruct,
context: &mut C,
) { ... }
fn walk_isset_construct(
&mut self,
isset_construct: &IssetConstruct,
context: &mut C,
) { ... }
fn walk_out_isset_construct(
&mut self,
isset_construct: &IssetConstruct,
context: &mut C,
) { ... }
fn walk_in_empty_construct(
&mut self,
empty_construct: &EmptyConstruct,
context: &mut C,
) { ... }
fn walk_empty_construct(
&mut self,
empty_construct: &EmptyConstruct,
context: &mut C,
) { ... }
fn walk_out_empty_construct(
&mut self,
empty_construct: &EmptyConstruct,
context: &mut C,
) { ... }
fn walk_in_eval_construct(
&mut self,
eval_construct: &EvalConstruct,
context: &mut C,
) { ... }
fn walk_eval_construct(
&mut self,
eval_construct: &EvalConstruct,
context: &mut C,
) { ... }
fn walk_out_eval_construct(
&mut self,
eval_construct: &EvalConstruct,
context: &mut C,
) { ... }
fn walk_in_include_construct(
&mut self,
include_construct: &IncludeConstruct,
context: &mut C,
) { ... }
fn walk_include_construct(
&mut self,
include_construct: &IncludeConstruct,
context: &mut C,
) { ... }
fn walk_out_include_construct(
&mut self,
include_construct: &IncludeConstruct,
context: &mut C,
) { ... }
fn walk_in_include_once_construct(
&mut self,
include_once_construct: &IncludeOnceConstruct,
context: &mut C,
) { ... }
fn walk_include_once_construct(
&mut self,
include_once_construct: &IncludeOnceConstruct,
context: &mut C,
) { ... }
fn walk_out_include_once_construct(
&mut self,
include_once_construct: &IncludeOnceConstruct,
context: &mut C,
) { ... }
fn walk_in_require_construct(
&mut self,
require_construct: &RequireConstruct,
context: &mut C,
) { ... }
fn walk_require_construct(
&mut self,
require_construct: &RequireConstruct,
context: &mut C,
) { ... }
fn walk_out_require_construct(
&mut self,
require_construct: &RequireConstruct,
context: &mut C,
) { ... }
fn walk_in_require_once_construct(
&mut self,
require_once_construct: &RequireOnceConstruct,
context: &mut C,
) { ... }
fn walk_require_once_construct(
&mut self,
require_once_construct: &RequireOnceConstruct,
context: &mut C,
) { ... }
fn walk_out_require_once_construct(
&mut self,
require_once_construct: &RequireOnceConstruct,
context: &mut C,
) { ... }
fn walk_in_print_construct(
&mut self,
print_construct: &PrintConstruct,
context: &mut C,
) { ... }
fn walk_print_construct(
&mut self,
print_construct: &PrintConstruct,
context: &mut C,
) { ... }
fn walk_out_print_construct(
&mut self,
print_construct: &PrintConstruct,
context: &mut C,
) { ... }
fn walk_in_exit_construct(
&mut self,
exit_construct: &ExitConstruct,
context: &mut C,
) { ... }
fn walk_exit_construct(
&mut self,
exit_construct: &ExitConstruct,
context: &mut C,
) { ... }
fn walk_out_exit_construct(
&mut self,
exit_construct: &ExitConstruct,
context: &mut C,
) { ... }
fn walk_in_die_construct(
&mut self,
die_construct: &DieConstruct,
context: &mut C,
) { ... }
fn walk_die_construct(
&mut self,
die_construct: &DieConstruct,
context: &mut C,
) { ... }
fn walk_out_die_construct(
&mut self,
die_construct: &DieConstruct,
context: &mut C,
) { ... }
fn walk_in_throw(&mut self, throw: &Throw, context: &mut C) { ... }
fn walk_throw(&mut self, throw: &Throw, context: &mut C) { ... }
fn walk_out_throw(&mut self, throw: &Throw, context: &mut C) { ... }
fn walk_in_clone(&mut self, clone: &Clone, context: &mut C) { ... }
fn walk_clone(&mut self, clone: &Clone, context: &mut C) { ... }
fn walk_out_clone(&mut self, clone: &Clone, context: &mut C) { ... }
fn walk_in_call(&mut self, call: &Call, context: &mut C) { ... }
fn walk_call(&mut self, call: &Call, context: &mut C) { ... }
fn walk_out_call(&mut self, call: &Call, context: &mut C) { ... }
fn walk_in_function_call(
&mut self,
function_call: &FunctionCall,
context: &mut C,
) { ... }
fn walk_function_call(
&mut self,
function_call: &FunctionCall,
context: &mut C,
) { ... }
fn walk_out_function_call(
&mut self,
function_call: &FunctionCall,
context: &mut C,
) { ... }
fn walk_in_method_call(&mut self, method_call: &MethodCall, context: &mut C) { ... }
fn walk_method_call(&mut self, method_call: &MethodCall, context: &mut C) { ... }
fn walk_out_method_call(
&mut self,
method_call: &MethodCall,
context: &mut C,
) { ... }
fn walk_in_null_safe_method_call(
&mut self,
null_safe_method_call: &NullSafeMethodCall,
context: &mut C,
) { ... }
fn walk_null_safe_method_call(
&mut self,
null_safe_method_call: &NullSafeMethodCall,
context: &mut C,
) { ... }
fn walk_out_null_safe_method_call(
&mut self,
null_safe_method_call: &NullSafeMethodCall,
context: &mut C,
) { ... }
fn walk_in_static_method_call(
&mut self,
static_method_call: &StaticMethodCall,
context: &mut C,
) { ... }
fn walk_static_method_call(
&mut self,
static_method_call: &StaticMethodCall,
context: &mut C,
) { ... }
fn walk_out_static_method_call(
&mut self,
static_method_call: &StaticMethodCall,
context: &mut C,
) { ... }
fn walk_in_class_like_member_selector(
&mut self,
class_like_member_selector: &ClassLikeMemberSelector,
context: &mut C,
) { ... }
fn walk_class_like_member_selector(
&mut self,
class_like_member_selector: &ClassLikeMemberSelector,
context: &mut C,
) { ... }
fn walk_out_class_like_member_selector(
&mut self,
class_like_member_selector: &ClassLikeMemberSelector,
context: &mut C,
) { ... }
fn walk_in_class_like_member_expression_selector(
&mut self,
class_like_member_expression_selector: &ClassLikeMemberExpressionSelector,
context: &mut C,
) { ... }
fn walk_class_like_member_expression_selector(
&mut self,
class_like_member_expression_selector: &ClassLikeMemberExpressionSelector,
context: &mut C,
) { ... }
fn walk_out_class_like_member_expression_selector(
&mut self,
class_like_member_expression_selector: &ClassLikeMemberExpressionSelector,
context: &mut C,
) { ... }
fn walk_in_constant_access(
&mut self,
constant_access: &ConstantAccess,
context: &mut C,
) { ... }
fn walk_constant_access(
&mut self,
constant_access: &ConstantAccess,
context: &mut C,
) { ... }
fn walk_out_constant_access(
&mut self,
constant_access: &ConstantAccess,
context: &mut C,
) { ... }
fn walk_in_access(&mut self, access: &Access, context: &mut C) { ... }
fn walk_access(&mut self, access: &Access, context: &mut C) { ... }
fn walk_out_access(&mut self, access: &Access, context: &mut C) { ... }
fn walk_in_property_access(
&mut self,
property_access: &PropertyAccess,
context: &mut C,
) { ... }
fn walk_property_access(
&mut self,
property_access: &PropertyAccess,
context: &mut C,
) { ... }
fn walk_out_property_access(
&mut self,
property_access: &PropertyAccess,
context: &mut C,
) { ... }
fn walk_in_null_safe_property_access(
&mut self,
null_safe_property_access: &NullSafePropertyAccess,
context: &mut C,
) { ... }
fn walk_null_safe_property_access(
&mut self,
null_safe_property_access: &NullSafePropertyAccess,
context: &mut C,
) { ... }
fn walk_out_null_safe_property_access(
&mut self,
null_safe_property_access: &NullSafePropertyAccess,
context: &mut C,
) { ... }
fn walk_in_static_property_access(
&mut self,
static_property_access: &StaticPropertyAccess,
context: &mut C,
) { ... }
fn walk_static_property_access(
&mut self,
static_property_access: &StaticPropertyAccess,
context: &mut C,
) { ... }
fn walk_out_static_property_access(
&mut self,
static_property_access: &StaticPropertyAccess,
context: &mut C,
) { ... }
fn walk_in_class_constant_access(
&mut self,
class_constant_access: &ClassConstantAccess,
context: &mut C,
) { ... }
fn walk_class_constant_access(
&mut self,
class_constant_access: &ClassConstantAccess,
context: &mut C,
) { ... }
fn walk_out_class_constant_access(
&mut self,
class_constant_access: &ClassConstantAccess,
context: &mut C,
) { ... }
fn walk_in_class_like_constant_selector(
&mut self,
class_like_constant_selector: &ClassLikeConstantSelector,
context: &mut C,
) { ... }
fn walk_class_like_constant_selector(
&mut self,
class_like_constant_selector: &ClassLikeConstantSelector,
context: &mut C,
) { ... }
fn walk_out_class_like_constant_selector(
&mut self,
class_like_constant_selector: &ClassLikeConstantSelector,
context: &mut C,
) { ... }
fn walk_in_closure_creation(
&mut self,
closure_creation: &ClosureCreation,
context: &mut C,
) { ... }
fn walk_closure_creation(
&mut self,
closure_creation: &ClosureCreation,
context: &mut C,
) { ... }
fn walk_out_closure_creation(
&mut self,
closure_creation: &ClosureCreation,
context: &mut C,
) { ... }
fn walk_in_function_closure_creation(
&mut self,
function_closure_creation: &FunctionClosureCreation,
context: &mut C,
) { ... }
fn walk_function_closure_creation(
&mut self,
function_closure_creation: &FunctionClosureCreation,
context: &mut C,
) { ... }
fn walk_out_function_closure_creation(
&mut self,
function_closure_creation: &FunctionClosureCreation,
context: &mut C,
) { ... }
fn walk_in_method_closure_creation(
&mut self,
method_closure_creation: &MethodClosureCreation,
context: &mut C,
) { ... }
fn walk_method_closure_creation(
&mut self,
method_closure_creation: &MethodClosureCreation,
context: &mut C,
) { ... }
fn walk_out_method_closure_creation(
&mut self,
method_closure_creation: &MethodClosureCreation,
context: &mut C,
) { ... }
fn walk_in_static_method_closure_creation(
&mut self,
static_method_closure_creation: &StaticMethodClosureCreation,
context: &mut C,
) { ... }
fn walk_static_method_closure_creation(
&mut self,
static_method_closure_creation: &StaticMethodClosureCreation,
context: &mut C,
) { ... }
fn walk_out_static_method_closure_creation(
&mut self,
static_method_closure_creation: &StaticMethodClosureCreation,
context: &mut C,
) { ... }
fn walk_in_parent_keyword(
&mut self,
parent_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_parent_keyword(&mut self, parent_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_parent_keyword(
&mut self,
parent_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_in_static_keyword(
&mut self,
static_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_static_keyword(&mut self, static_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_static_keyword(
&mut self,
static_keyword: &Keyword,
context: &mut C,
) { ... }
fn walk_in_self_keyword(&mut self, self_keyword: &Keyword, context: &mut C) { ... }
fn walk_self_keyword(&mut self, self_keyword: &Keyword, context: &mut C) { ... }
fn walk_out_self_keyword(&mut self, self_keyword: &Keyword, context: &mut C) { ... }
fn walk_in_instantiation(
&mut self,
instantiation: &Instantiation,
context: &mut C,
) { ... }
fn walk_instantiation(
&mut self,
instantiation: &Instantiation,
context: &mut C,
) { ... }
fn walk_out_instantiation(
&mut self,
instantiation: &Instantiation,
context: &mut C,
) { ... }
fn walk_in_magic_constant(
&mut self,
magic_constant: &MagicConstant,
context: &mut C,
) { ... }
fn walk_magic_constant(
&mut self,
magic_constant: &MagicConstant,
context: &mut C,
) { ... }
fn walk_out_magic_constant(
&mut self,
magic_constant: &MagicConstant,
context: &mut C,
) { ... }
fn walk_in_hint(&mut self, hint: &Hint, context: &mut C) { ... }
fn walk_hint(&mut self, hint: &Hint, context: &mut C) { ... }
fn walk_out_hint(&mut self, hint: &Hint, context: &mut C) { ... }
fn walk_in_parenthesized_hint(
&mut self,
parenthesized_hint: &ParenthesizedHint,
context: &mut C,
) { ... }
fn walk_parenthesized_hint(
&mut self,
parenthesized_hint: &ParenthesizedHint,
context: &mut C,
) { ... }
fn walk_out_parenthesized_hint(
&mut self,
parenthesized_hint: &ParenthesizedHint,
context: &mut C,
) { ... }
fn walk_in_nullable_hint(
&mut self,
nullable_hint: &NullableHint,
context: &mut C,
) { ... }
fn walk_nullable_hint(
&mut self,
nullable_hint: &NullableHint,
context: &mut C,
) { ... }
fn walk_out_nullable_hint(
&mut self,
nullable_hint: &NullableHint,
context: &mut C,
) { ... }
fn walk_in_union_hint(&mut self, union_hint: &UnionHint, context: &mut C) { ... }
fn walk_union_hint(&mut self, union_hint: &UnionHint, context: &mut C) { ... }
fn walk_out_union_hint(&mut self, union_hint: &UnionHint, context: &mut C) { ... }
fn walk_in_intersection_hint(
&mut self,
intersection_hint: &IntersectionHint,
context: &mut C,
) { ... }
fn walk_intersection_hint(
&mut self,
intersection_hint: &IntersectionHint,
context: &mut C,
) { ... }
fn walk_out_intersection_hint(
&mut self,
intersection_hint: &IntersectionHint,
context: &mut C,
) { ... }
fn walk_in_keyword(&mut self, keyword: &Keyword, context: &mut C) { ... }
fn walk_keyword(&mut self, keyword: &Keyword, context: &mut C) { ... }
fn walk_out_keyword(&mut self, keyword: &Keyword, context: &mut C) { ... }
}Expand description
A trait that defines a mutable walker to traverse AST nodes.
Each method can be overridden to customize how a node is entered, walked, and exited.