bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Sync mut_visit function names with immut visit ones (s/noop_visit/walk/)

Browse source
This commit is contained in:
Oli Scherer 2024-07-10 08:17:13 +00:00
parent 6f85f20520
commit 754bdef793
9 changed files with 226 additions and 235 deletions
Download patch file Download diff file Expand all files Collapse all files

259
compiler/rustc_ast/src/mut_visit.rs
View file

@ -36,7 +36,7 @@ impl<A: Array> ExpectOne<A> for SmallVec<A> {
} }
pub trait NoopVisitItemKind { pub trait NoopVisitItemKind {
fn noop_visit( fn walk(
&mut self, &mut self,
ctxt: Option<AssocCtxt>, ctxt: Option<AssocCtxt>,
ident: Ident, ident: Ident,
@ -86,35 +86,35 @@ pub trait MutVisitor: Sized {
// forget to add handling for it. // forget to add handling for it.
fn visit_crate(&mut self, c: &mut Crate) { fn visit_crate(&mut self, c: &mut Crate) {
noop_visit_crate(c, self) walk_crate(c, self)
} }
fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) { fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) {
noop_visit_meta_list_item(list_item, self); walk_meta_list_item(list_item, self);
} }
fn visit_meta_item(&mut self, meta_item: &mut MetaItem) { fn visit_meta_item(&mut self, meta_item: &mut MetaItem) {
noop_visit_meta_item(meta_item, self); walk_meta_item(meta_item, self);
} }
fn visit_use_tree(&mut self, use_tree: &mut UseTree) { fn visit_use_tree(&mut self, use_tree: &mut UseTree) {
noop_visit_use_tree(use_tree, self); walk_use_tree(use_tree, self);
} }
fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> { fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
noop_flat_map_item(ni, None, self) walk_flat_map_item(ni, None, self)
} }
fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> { fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
noop_flat_map_item(i, None, self) walk_flat_map_item(i, None, self)
} }
fn visit_fn_header(&mut self, header: &mut FnHeader) { fn visit_fn_header(&mut self, header: &mut FnHeader) {
noop_visit_fn_header(header, self); walk_fn_header(header, self);
} }
fn flat_map_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> { fn flat_map_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> {
noop_flat_map_field_def(fd, self) walk_flat_map_field_def(fd, self)
} }
fn flat_map_assoc_item( fn flat_map_assoc_item(
@ -122,48 +122,48 @@ pub trait MutVisitor: Sized {
i: P<AssocItem>, i: P<AssocItem>,
ctxt: AssocCtxt, ctxt: AssocCtxt,
) -> SmallVec<[P<AssocItem>; 1]> { ) -> SmallVec<[P<AssocItem>; 1]> {
noop_flat_map_item(i, Some(ctxt), self) walk_flat_map_item(i, Some(ctxt), self)
} }
fn visit_fn_decl(&mut self, d: &mut P<FnDecl>) { fn visit_fn_decl(&mut self, d: &mut P<FnDecl>) {
noop_visit_fn_decl(d, self); walk_fn_decl(d, self);
} }
/// `Span` and `NodeId` are mutated at the caller site. /// `Span` and `NodeId` are mutated at the caller site.
fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) { fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
noop_visit_fn(fk, self) walk_fn(fk, self)
} }
fn visit_coroutine_kind(&mut self, a: &mut CoroutineKind) { fn visit_coroutine_kind(&mut self, a: &mut CoroutineKind) {
noop_visit_coroutine_kind(a, self); walk_coroutine_kind(a, self);
} }
fn visit_closure_binder(&mut self, b: &mut ClosureBinder) { fn visit_closure_binder(&mut self, b: &mut ClosureBinder) {
noop_visit_closure_binder(b, self); walk_closure_binder(b, self);
} }
fn visit_block(&mut self, b: &mut P<Block>) { fn visit_block(&mut self, b: &mut P<Block>) {
noop_visit_block(b, self); walk_block(b, self);
} }
fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> { fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
noop_flat_map_stmt(s, self) walk_flat_map_stmt(s, self)
} }
fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> { fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
noop_flat_map_arm(arm, self) walk_flat_map_arm(arm, self)
} }
fn visit_pat(&mut self, p: &mut P<Pat>) { fn visit_pat(&mut self, p: &mut P<Pat>) {
noop_visit_pat(p, self); walk_pat(p, self);
} }
fn visit_anon_const(&mut self, c: &mut AnonConst) { fn visit_anon_const(&mut self, c: &mut AnonConst) {
noop_visit_anon_const(c, self); walk_anon_const(c, self);
} }
fn visit_expr(&mut self, e: &mut P<Expr>) { fn visit_expr(&mut self, e: &mut P<Expr>) {
noop_visit_expr(e, self); walk_expr(e, self);
} }
/// This method is a hack to workaround unstable of `stmt_expr_attributes`. /// This method is a hack to workaround unstable of `stmt_expr_attributes`.
@ -177,127 +177,127 @@ pub trait MutVisitor: Sized {
} }
fn visit_generic_arg(&mut self, arg: &mut GenericArg) { fn visit_generic_arg(&mut self, arg: &mut GenericArg) {
noop_visit_generic_arg(arg, self); walk_generic_arg(arg, self);
} }
fn visit_ty(&mut self, t: &mut P<Ty>) { fn visit_ty(&mut self, t: &mut P<Ty>) {
noop_visit_ty(t, self); walk_ty(t, self);
} }
fn visit_lifetime(&mut self, l: &mut Lifetime) { fn visit_lifetime(&mut self, l: &mut Lifetime) {
noop_visit_lifetime(l, self); walk_lifetime(l, self);
} }
fn visit_assoc_item_constraint(&mut self, c: &mut AssocItemConstraint) { fn visit_assoc_item_constraint(&mut self, c: &mut AssocItemConstraint) {
noop_visit_assoc_item_constraint(c, self); walk_assoc_item_constraint(c, self);
} }
fn visit_foreign_mod(&mut self, nm: &mut ForeignMod) { fn visit_foreign_mod(&mut self, nm: &mut ForeignMod) {
noop_visit_foreign_mod(nm, self); walk_foreign_mod(nm, self);
} }
fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> { fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
noop_flat_map_variant(v, self) walk_flat_map_variant(v, self)
} }
fn visit_ident(&mut self, i: &mut Ident) { fn visit_ident(&mut self, i: &mut Ident) {
noop_visit_ident(i, self); walk_ident(i, self);
} }
fn visit_path(&mut self, p: &mut Path) { fn visit_path(&mut self, p: &mut Path) {
noop_visit_path(p, self); walk_path(self, p);
} }
fn visit_path_segment(&mut self, p: &mut PathSegment) { fn visit_path_segment(&mut self, p: &mut PathSegment) {
noop_visit_path_segment(p, self) walk_path_segment(self, p)
} }
fn visit_qself(&mut self, qs: &mut Option<P<QSelf>>) { fn visit_qself(&mut self, qs: &mut Option<P<QSelf>>) {
noop_visit_qself(qs, self); walk_qself(qs, self);
} }
fn visit_generic_args(&mut self, p: &mut GenericArgs) { fn visit_generic_args(&mut self, p: &mut GenericArgs) {
noop_visit_generic_args(p, self); walk_generic_args(p, self);
} }
fn visit_angle_bracketed_parameter_data(&mut self, p: &mut AngleBracketedArgs) { fn visit_angle_bracketed_parameter_data(&mut self, p: &mut AngleBracketedArgs) {
noop_visit_angle_bracketed_parameter_data(p, self); walk_angle_bracketed_parameter_data(p, self);
} }
fn visit_parenthesized_parameter_data(&mut self, p: &mut ParenthesizedArgs) { fn visit_parenthesized_parameter_data(&mut self, p: &mut ParenthesizedArgs) {
noop_visit_parenthesized_parameter_data(p, self); walk_parenthesized_parameter_data(p, self);
} }
fn visit_local(&mut self, l: &mut P<Local>) { fn visit_local(&mut self, l: &mut P<Local>) {
noop_visit_local(l, self); walk_local(l, self);
} }
fn visit_mac_call(&mut self, mac: &mut MacCall) { fn visit_mac_call(&mut self, mac: &mut MacCall) {
noop_visit_mac(mac, self); walk_mac(mac, self);
} }
fn visit_macro_def(&mut self, def: &mut MacroDef) { fn visit_macro_def(&mut self, def: &mut MacroDef) {
noop_visit_macro_def(def, self); walk_macro_def(def, self);
} }
fn visit_label(&mut self, label: &mut Label) { fn visit_label(&mut self, label: &mut Label) {
noop_visit_label(label, self); walk_label(label, self);
} }
fn visit_attribute(&mut self, at: &mut Attribute) { fn visit_attribute(&mut self, at: &mut Attribute) {
noop_visit_attribute(at, self); walk_attribute(at, self);
} }
fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> { fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
noop_flat_map_param(param, self) walk_flat_map_param(param, self)
} }
fn visit_generics(&mut self, generics: &mut Generics) { fn visit_generics(&mut self, generics: &mut Generics) {
noop_visit_generics(generics, self); walk_generics(generics, self);
} }
fn visit_trait_ref(&mut self, tr: &mut TraitRef) { fn visit_trait_ref(&mut self, tr: &mut TraitRef) {
noop_visit_trait_ref(tr, self); walk_trait_ref(tr, self);
} }
fn visit_poly_trait_ref(&mut self, p: &mut PolyTraitRef) { fn visit_poly_trait_ref(&mut self, p: &mut PolyTraitRef) {
noop_visit_poly_trait_ref(p, self); walk_poly_trait_ref(p, self);
} }
fn visit_variant_data(&mut self, vdata: &mut VariantData) { fn visit_variant_data(&mut self, vdata: &mut VariantData) {
noop_visit_variant_data(vdata, self); walk_variant_data(vdata, self);
} }
fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> { fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
noop_flat_map_generic_param(param, self) walk_flat_map_generic_param(param, self)
} }
fn visit_param_bound(&mut self, tpb: &mut GenericBound, _ctxt: BoundKind) { fn visit_param_bound(&mut self, tpb: &mut GenericBound, _ctxt: BoundKind) {
noop_visit_param_bound(tpb, self); walk_param_bound(tpb, self);
} }
fn visit_precise_capturing_arg(&mut self, arg: &mut PreciseCapturingArg) { fn visit_precise_capturing_arg(&mut self, arg: &mut PreciseCapturingArg) {
noop_visit_precise_capturing_arg(arg, self); walk_precise_capturing_arg(arg, self);
} }
fn visit_mt(&mut self, mt: &mut MutTy) { fn visit_mt(&mut self, mt: &mut MutTy) {
noop_visit_mt(mt, self); walk_mt(mt, self);
} }
fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> { fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
noop_flat_map_expr_field(f, self) walk_flat_map_expr_field(f, self)
} }
fn visit_where_clause(&mut self, where_clause: &mut WhereClause) { fn visit_where_clause(&mut self, where_clause: &mut WhereClause) {
noop_visit_where_clause(where_clause, self); walk_where_clause(where_clause, self);
} }
fn visit_where_predicate(&mut self, where_predicate: &mut WherePredicate) { fn visit_where_predicate(&mut self, where_predicate: &mut WherePredicate) {
noop_visit_where_predicate(where_predicate, self); walk_where_predicate(where_predicate, self);
} }
fn visit_vis(&mut self, vis: &mut Visibility) { fn visit_vis(&mut self, vis: &mut Visibility) {
noop_visit_vis(vis, self); walk_vis(vis, self);
} }
fn visit_id(&mut self, _id: &mut NodeId) { fn visit_id(&mut self, _id: &mut NodeId) {
@ -309,23 +309,23 @@ pub trait MutVisitor: Sized {
} }
fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> { fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
noop_flat_map_pat_field(fp, self) walk_flat_map_pat_field(fp, self)
} }
fn visit_inline_asm(&mut self, asm: &mut InlineAsm) { fn visit_inline_asm(&mut self, asm: &mut InlineAsm) {
noop_visit_inline_asm(asm, self) walk_inline_asm(asm, self)
} }
fn visit_inline_asm_sym(&mut self, sym: &mut InlineAsmSym) { fn visit_inline_asm_sym(&mut self, sym: &mut InlineAsmSym) {
noop_visit_inline_asm_sym(sym, self) walk_inline_asm_sym(sym, self)
} }
fn visit_format_args(&mut self, fmt: &mut FormatArgs) { fn visit_format_args(&mut self, fmt: &mut FormatArgs) {
noop_visit_format_args(fmt, self) walk_format_args(fmt, self)
} }
fn visit_capture_by(&mut self, capture_by: &mut CaptureBy) { fn visit_capture_by(&mut self, capture_by: &mut CaptureBy) {
noop_visit_capture_by(capture_by, self) walk_capture_by(capture_by, self)
} }
} }
@ -422,7 +422,7 @@ pub fn visit_delim_span<T: MutVisitor>(DelimSpan { open, close }: &mut DelimSpan
vis.visit_span(close); vis.visit_span(close);
} }
pub fn noop_flat_map_pat_field<T: MutVisitor>( pub fn walk_flat_map_pat_field<T: MutVisitor>(
mut fp: PatField, mut fp: PatField,
vis: &mut T, vis: &mut T,
) -> SmallVec<[PatField; 1]> { ) -> SmallVec<[PatField; 1]> {
@ -435,7 +435,7 @@ pub fn noop_flat_map_pat_field<T: MutVisitor>(
smallvec![fp] smallvec![fp]
} }
fn noop_visit_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) { fn walk_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) {
let UseTree { prefix, kind, span } = use_tree; let UseTree { prefix, kind, span } = use_tree;
vis.visit_path(prefix); vis.visit_path(prefix);
match kind { match kind {
@ -452,7 +452,7 @@ fn noop_visit_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[Arm; 1]> { pub fn walk_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[Arm; 1]> {
let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = &mut arm; let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = &mut arm;
vis.visit_id(id); vis.visit_id(id);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
@ -463,7 +463,7 @@ pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[
smallvec![arm] smallvec![arm]
} }
fn noop_visit_assoc_item_constraint<T: MutVisitor>( fn walk_assoc_item_constraint<T: MutVisitor>(
AssocItemConstraint { id, ident, gen_args, kind, span }: &mut AssocItemConstraint, AssocItemConstraint { id, ident, gen_args, kind, span }: &mut AssocItemConstraint,
vis: &mut T, vis: &mut T,
) { ) {
@ -482,7 +482,7 @@ fn noop_visit_assoc_item_constraint<T: MutVisitor>(
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) { pub fn walk_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
let Ty { id, kind, span, tokens } = ty.deref_mut(); let Ty { id, kind, span, tokens } = ty.deref_mut();
vis.visit_id(id); vis.visit_id(id);
match kind { match kind {
@ -534,13 +534,13 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) { fn walk_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) {
let ForeignMod { safety, abi: _, items } = foreign_mod; let ForeignMod { safety, abi: _, items } = foreign_mod;
visit_safety(safety, vis); visit_safety(safety, vis);
items.flat_map_in_place(|item| vis.flat_map_foreign_item(item)); items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
} }
pub fn noop_flat_map_variant<T: MutVisitor>( pub fn walk_flat_map_variant<T: MutVisitor>(
mut variant: Variant, mut variant: Variant,
visitor: &mut T, visitor: &mut T,
) -> SmallVec<[Variant; 1]> { ) -> SmallVec<[Variant; 1]> {
@ -555,18 +555,18 @@ pub fn noop_flat_map_variant<T: MutVisitor>(
smallvec![variant] smallvec![variant]
} }
fn noop_visit_ident<T: MutVisitor>(Ident { name: _, span }: &mut Ident, vis: &mut T) { fn walk_ident<T: MutVisitor>(Ident { name: _, span }: &mut Ident, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_path_segment<T: MutVisitor>(segment: &mut PathSegment, vis: &mut T) { fn walk_path_segment<T: MutVisitor>(vis: &mut T, segment: &mut PathSegment) {
let PathSegment { ident, id, args } = segment; let PathSegment { ident, id, args } = segment;
vis.visit_id(id); vis.visit_id(id);
vis.visit_ident(ident); vis.visit_ident(ident);
visit_opt(args, |args| vis.visit_generic_args(args)); visit_opt(args, |args| vis.visit_generic_args(args));
} }
fn noop_visit_path<T: MutVisitor>(Path { segments, span, tokens }: &mut Path, vis: &mut T) { fn walk_path<T: MutVisitor>(vis: &mut T, Path { segments, span, tokens }: &mut Path) {
for segment in segments { for segment in segments {
vis.visit_path_segment(segment); vis.visit_path_segment(segment);
} }
@ -574,7 +574,7 @@ fn noop_visit_path<T: MutVisitor>(Path { segments, span, tokens }: &mut Path, vi
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) { fn walk_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) {
visit_opt(qself, |qself| { visit_opt(qself, |qself| {
let QSelf { ty, path_span, position: _ } = &mut **qself; let QSelf { ty, path_span, position: _ } = &mut **qself;
vis.visit_ty(ty); vis.visit_ty(ty);
@ -582,7 +582,7 @@ fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) {
}) })
} }
fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &mut T) { fn walk_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &mut T) {
match generic_args { match generic_args {
GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data), GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data),
GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data), GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data),
@ -590,7 +590,7 @@ fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &
} }
} }
fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) { fn walk_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) {
match arg { match arg {
GenericArg::Lifetime(lt) => vis.visit_lifetime(lt), GenericArg::Lifetime(lt) => vis.visit_lifetime(lt),
GenericArg::Type(ty) => vis.visit_ty(ty), GenericArg::Type(ty) => vis.visit_ty(ty),
@ -598,10 +598,7 @@ fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) {
} }
} }
fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>( fn walk_angle_bracketed_parameter_data<T: MutVisitor>(data: &mut AngleBracketedArgs, vis: &mut T) {
data: &mut AngleBracketedArgs,
vis: &mut T,
) {
let AngleBracketedArgs { args, span } = data; let AngleBracketedArgs { args, span } = data;
visit_thin_vec(args, |arg| match arg { visit_thin_vec(args, |arg| match arg {
AngleBracketedArg::Arg(arg) => vis.visit_generic_arg(arg), AngleBracketedArg::Arg(arg) => vis.visit_generic_arg(arg),
@ -610,18 +607,15 @@ fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_parenthesized_parameter_data<T: MutVisitor>( fn walk_parenthesized_parameter_data<T: MutVisitor>(args: &mut ParenthesizedArgs, vis: &mut T) {
args: &mut ParenthesizedArgs,
vis: &mut T,
) {
let ParenthesizedArgs { inputs, output, span, inputs_span } = args; let ParenthesizedArgs { inputs, output, span, inputs_span } = args;
visit_thin_vec(inputs, |input| vis.visit_ty(input)); visit_thin_vec(inputs, |input| vis.visit_ty(input));
noop_visit_fn_ret_ty(output, vis); walk_fn_ret_ty(output, vis);
vis.visit_span(span); vis.visit_span(span);
vis.visit_span(inputs_span); vis.visit_span(inputs_span);
} }
fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) { fn walk_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
let Local { id, pat, ty, kind, span, colon_sp, attrs, tokens } = local.deref_mut(); let Local { id, pat, ty, kind, span, colon_sp, attrs, tokens } = local.deref_mut();
vis.visit_id(id); vis.visit_id(id);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
@ -642,7 +636,7 @@ fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) { fn walk_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
let Attribute { kind, id: _, style: _, span } = attr; let Attribute { kind, id: _, style: _, span } = attr;
match kind { match kind {
AttrKind::Normal(normal) => { AttrKind::Normal(normal) => {
@ -660,25 +654,25 @@ fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_mac<T: MutVisitor>(mac: &mut MacCall, vis: &mut T) { fn walk_mac<T: MutVisitor>(mac: &mut MacCall, vis: &mut T) {
let MacCall { path, args } = mac; let MacCall { path, args } = mac;
vis.visit_path(path); vis.visit_path(path);
visit_delim_args(args, vis); visit_delim_args(args, vis);
} }
fn noop_visit_macro_def<T: MutVisitor>(macro_def: &mut MacroDef, vis: &mut T) { fn walk_macro_def<T: MutVisitor>(macro_def: &mut MacroDef, vis: &mut T) {
let MacroDef { body, macro_rules: _ } = macro_def; let MacroDef { body, macro_rules: _ } = macro_def;
visit_delim_args(body, vis); visit_delim_args(body, vis);
} }
fn noop_visit_meta_list_item<T: MutVisitor>(li: &mut NestedMetaItem, vis: &mut T) { fn walk_meta_list_item<T: MutVisitor>(li: &mut NestedMetaItem, vis: &mut T) {
match li { match li {
NestedMetaItem::MetaItem(mi) => vis.visit_meta_item(mi), NestedMetaItem::MetaItem(mi) => vis.visit_meta_item(mi),
NestedMetaItem::Lit(_lit) => {} NestedMetaItem::Lit(_lit) => {}
} }
} }
fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) { fn walk_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
let MetaItem { unsafety: _, path: _, kind, span } = mi; let MetaItem { unsafety: _, path: _, kind, span } = mi;
match kind { match kind {
MetaItemKind::Word => {} MetaItemKind::Word => {}
@ -688,7 +682,7 @@ fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_flat_map_param<T: MutVisitor>(mut param: Param, vis: &mut T) -> SmallVec<[Param; 1]> { pub fn walk_flat_map_param<T: MutVisitor>(mut param: Param, vis: &mut T) -> SmallVec<[Param; 1]> {
let Param { attrs, id, pat, span, ty, is_placeholder: _ } = &mut param; let Param { attrs, id, pat, span, ty, is_placeholder: _ } = &mut param;
vis.visit_id(id); vis.visit_id(id);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
@ -873,7 +867,7 @@ fn visit_constness<T: MutVisitor>(constness: &mut Const, vis: &mut T) {
} }
} }
fn noop_visit_closure_binder<T: MutVisitor>(binder: &mut ClosureBinder, vis: &mut T) { fn walk_closure_binder<T: MutVisitor>(binder: &mut ClosureBinder, vis: &mut T) {
match binder { match binder {
ClosureBinder::NotPresent => {} ClosureBinder::NotPresent => {}
ClosureBinder::For { span: _, generic_params } => { ClosureBinder::For { span: _, generic_params } => {
@ -882,7 +876,7 @@ fn noop_visit_closure_binder<T: MutVisitor>(binder: &mut ClosureBinder, vis: &mu
} }
} }
fn noop_visit_coroutine_kind<T: MutVisitor>(coroutine_kind: &mut CoroutineKind, vis: &mut T) { fn walk_coroutine_kind<T: MutVisitor>(coroutine_kind: &mut CoroutineKind, vis: &mut T) {
match coroutine_kind { match coroutine_kind {
CoroutineKind::Async { span, closure_id, return_impl_trait_id } CoroutineKind::Async { span, closure_id, return_impl_trait_id }
| CoroutineKind::Gen { span, closure_id, return_impl_trait_id } | CoroutineKind::Gen { span, closure_id, return_impl_trait_id }
@ -894,7 +888,7 @@ fn noop_visit_coroutine_kind<T: MutVisitor>(coroutine_kind: &mut CoroutineKind,
} }
} }
fn noop_visit_fn<T: MutVisitor>(kind: FnKind<'_>, vis: &mut T) { fn walk_fn<T: MutVisitor>(kind: FnKind<'_>, vis: &mut T) {
match kind { match kind {
FnKind::Fn(_ctxt, _ident, FnSig { header, decl, span }, generics, body) => { FnKind::Fn(_ctxt, _ident, FnSig { header, decl, span }, generics, body) => {
// Identifier and visibility are visited as a part of the item. // Identifier and visibility are visited as a part of the item.
@ -914,23 +908,23 @@ fn noop_visit_fn<T: MutVisitor>(kind: FnKind<'_>, vis: &mut T) {
} }
} }
fn noop_visit_fn_decl<T: MutVisitor>(decl: &mut P<FnDecl>, vis: &mut T) { fn walk_fn_decl<T: MutVisitor>(decl: &mut P<FnDecl>, vis: &mut T) {
let FnDecl { inputs, output } = decl.deref_mut(); let FnDecl { inputs, output } = decl.deref_mut();
inputs.flat_map_in_place(|param| vis.flat_map_param(param)); inputs.flat_map_in_place(|param| vis.flat_map_param(param));
noop_visit_fn_ret_ty(output, vis); walk_fn_ret_ty(output, vis);
} }
fn noop_visit_fn_ret_ty<T: MutVisitor>(fn_ret_ty: &mut FnRetTy, vis: &mut T) { fn walk_fn_ret_ty<T: MutVisitor>(fn_ret_ty: &mut FnRetTy, vis: &mut T) {
match fn_ret_ty { match fn_ret_ty {
FnRetTy::Default(span) => vis.visit_span(span), FnRetTy::Default(span) => vis.visit_span(span),
FnRetTy::Ty(ty) => vis.visit_ty(ty), FnRetTy::Ty(ty) => vis.visit_ty(ty),
} }
} }
fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) { fn walk_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) {
match pb { match pb {
GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty), GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty),
GenericBound::Outlives(lifetime) => noop_visit_lifetime(lifetime, vis), GenericBound::Outlives(lifetime) => walk_lifetime(lifetime, vis),
GenericBound::Use(args, span) => { GenericBound::Use(args, span) => {
for arg in args { for arg in args {
vis.visit_precise_capturing_arg(arg); vis.visit_precise_capturing_arg(arg);
@ -940,7 +934,7 @@ fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) {
} }
} }
fn noop_visit_precise_capturing_arg<T: MutVisitor>(arg: &mut PreciseCapturingArg, vis: &mut T) { fn walk_precise_capturing_arg<T: MutVisitor>(arg: &mut PreciseCapturingArg, vis: &mut T) {
match arg { match arg {
PreciseCapturingArg::Lifetime(lt) => { PreciseCapturingArg::Lifetime(lt) => {
vis.visit_lifetime(lt); vis.visit_lifetime(lt);
@ -952,7 +946,7 @@ fn noop_visit_precise_capturing_arg<T: MutVisitor>(arg: &mut PreciseCapturingArg
} }
} }
pub fn noop_flat_map_generic_param<T: MutVisitor>( pub fn walk_flat_map_generic_param<T: MutVisitor>(
mut param: GenericParam, mut param: GenericParam,
vis: &mut T, vis: &mut T,
) -> SmallVec<[GenericParam; 1]> { ) -> SmallVec<[GenericParam; 1]> {
@ -977,23 +971,23 @@ pub fn noop_flat_map_generic_param<T: MutVisitor>(
smallvec![param] smallvec![param]
} }
fn noop_visit_label<T: MutVisitor>(Label { ident }: &mut Label, vis: &mut T) { fn walk_label<T: MutVisitor>(Label { ident }: &mut Label, vis: &mut T) {
vis.visit_ident(ident); vis.visit_ident(ident);
} }
fn noop_visit_lifetime<T: MutVisitor>(Lifetime { id, ident }: &mut Lifetime, vis: &mut T) { fn walk_lifetime<T: MutVisitor>(Lifetime { id, ident }: &mut Lifetime, vis: &mut T) {
vis.visit_id(id); vis.visit_id(id);
vis.visit_ident(ident); vis.visit_ident(ident);
} }
fn noop_visit_generics<T: MutVisitor>(generics: &mut Generics, vis: &mut T) { fn walk_generics<T: MutVisitor>(generics: &mut Generics, vis: &mut T) {
let Generics { params, where_clause, span } = generics; let Generics { params, where_clause, span } = generics;
params.flat_map_in_place(|param| vis.flat_map_generic_param(param)); params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_where_clause(where_clause); vis.visit_where_clause(where_clause);
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_ty_alias_where_clauses<T: MutVisitor>(tawcs: &mut TyAliasWhereClauses, vis: &mut T) { fn walk_ty_alias_where_clauses<T: MutVisitor>(tawcs: &mut TyAliasWhereClauses, vis: &mut T) {
let TyAliasWhereClauses { before, after, split: _ } = tawcs; let TyAliasWhereClauses { before, after, split: _ } = tawcs;
let TyAliasWhereClause { has_where_token: _, span: span_before } = before; let TyAliasWhereClause { has_where_token: _, span: span_before } = before;
let TyAliasWhereClause { has_where_token: _, span: span_after } = after; let TyAliasWhereClause { has_where_token: _, span: span_after } = after;
@ -1001,13 +995,13 @@ fn noop_visit_ty_alias_where_clauses<T: MutVisitor>(tawcs: &mut TyAliasWhereClau
vis.visit_span(span_after); vis.visit_span(span_after);
} }
fn noop_visit_where_clause<T: MutVisitor>(wc: &mut WhereClause, vis: &mut T) { fn walk_where_clause<T: MutVisitor>(wc: &mut WhereClause, vis: &mut T) {
let WhereClause { has_where_token: _, predicates, span } = wc; let WhereClause { has_where_token: _, predicates, span } = wc;
visit_thin_vec(predicates, |predicate| vis.visit_where_predicate(predicate)); visit_thin_vec(predicates, |predicate| vis.visit_where_predicate(predicate));
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_where_predicate<T: MutVisitor>(pred: &mut WherePredicate, vis: &mut T) { fn walk_where_predicate<T: MutVisitor>(pred: &mut WherePredicate, vis: &mut T) {
match pred { match pred {
WherePredicate::BoundPredicate(bp) => { WherePredicate::BoundPredicate(bp) => {
let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp; let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp;
@ -1031,7 +1025,7 @@ fn noop_visit_where_predicate<T: MutVisitor>(pred: &mut WherePredicate, vis: &mu
} }
} }
fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T) { fn walk_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T) {
match vdata { match vdata {
VariantData::Struct { fields, recovered: _ } => { VariantData::Struct { fields, recovered: _ } => {
fields.flat_map_in_place(|field| vis.flat_map_field_def(field)); fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
@ -1044,19 +1038,19 @@ fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T)
} }
} }
fn noop_visit_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) { fn walk_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) {
vis.visit_id(ref_id); vis.visit_id(ref_id);
vis.visit_path(path); vis.visit_path(path);
} }
fn noop_visit_poly_trait_ref<T: MutVisitor>(p: &mut PolyTraitRef, vis: &mut T) { fn walk_poly_trait_ref<T: MutVisitor>(p: &mut PolyTraitRef, vis: &mut T) {
let PolyTraitRef { bound_generic_params, trait_ref, span } = p; let PolyTraitRef { bound_generic_params, trait_ref, span } = p;
bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param)); bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
vis.visit_trait_ref(trait_ref); vis.visit_trait_ref(trait_ref);
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_flat_map_field_def<T: MutVisitor>( pub fn walk_flat_map_field_def<T: MutVisitor>(
mut fd: FieldDef, mut fd: FieldDef,
visitor: &mut T, visitor: &mut T,
) -> SmallVec<[FieldDef; 1]> { ) -> SmallVec<[FieldDef; 1]> {
@ -1070,7 +1064,7 @@ pub fn noop_flat_map_field_def<T: MutVisitor>(
smallvec![fd] smallvec![fd]
} }
pub fn noop_flat_map_expr_field<T: MutVisitor>( pub fn walk_flat_map_expr_field<T: MutVisitor>(
mut f: ExprField, mut f: ExprField,
vis: &mut T, vis: &mut T,
) -> SmallVec<[ExprField; 1]> { ) -> SmallVec<[ExprField; 1]> {
@ -1083,11 +1077,11 @@ pub fn noop_flat_map_expr_field<T: MutVisitor>(
smallvec![f] smallvec![f]
} }
fn noop_visit_mt<T: MutVisitor>(MutTy { ty, mutbl: _ }: &mut MutTy, vis: &mut T) { fn walk_mt<T: MutVisitor>(MutTy { ty, mutbl: _ }: &mut MutTy, vis: &mut T) {
vis.visit_ty(ty); vis.visit_ty(ty);
} }
pub fn noop_visit_block<T: MutVisitor>(block: &mut P<Block>, vis: &mut T) { pub fn walk_block<T: MutVisitor>(block: &mut P<Block>, vis: &mut T) {
let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _ } = block.deref_mut(); let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _ } = block.deref_mut();
vis.visit_id(id); vis.visit_id(id);
stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt)); stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt));
@ -1095,18 +1089,18 @@ pub fn noop_visit_block<T: MutVisitor>(block: &mut P<Block>, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_visit_item_kind( pub fn walk_item_kind(
kind: &mut impl NoopVisitItemKind, kind: &mut impl NoopVisitItemKind,
ident: Ident, ident: Ident,
span: Span, span: Span,
id: NodeId, id: NodeId,
vis: &mut impl MutVisitor, vis: &mut impl MutVisitor,
) { ) {
kind.noop_visit(None, ident, span, id, vis) kind.walk(None, ident, span, id, vis)
} }
impl NoopVisitItemKind for ItemKind { impl NoopVisitItemKind for ItemKind {
fn noop_visit( fn walk(
&mut self, &mut self,
ctxt: Option<AssocCtxt>, ctxt: Option<AssocCtxt>,
ident: Ident, ident: Ident,
@ -1147,7 +1141,7 @@ impl NoopVisitItemKind for ItemKind {
vis.visit_generics(generics); vis.visit_generics(generics);
visit_bounds(bounds, BoundKind::Bound, vis); visit_bounds(bounds, BoundKind::Bound, vis);
visit_opt(ty, |ty| vis.visit_ty(ty)); visit_opt(ty, |ty| vis.visit_ty(ty));
noop_visit_ty_alias_where_clauses(where_clauses, vis); walk_ty_alias_where_clauses(where_clauses, vis);
} }
ItemKind::Enum(EnumDef { variants }, generics) => { ItemKind::Enum(EnumDef { variants }, generics) => {
vis.visit_generics(generics); vis.visit_generics(generics);
@ -1226,7 +1220,7 @@ impl NoopVisitItemKind for ItemKind {
} }
impl NoopVisitItemKind for AssocItemKind { impl NoopVisitItemKind for AssocItemKind {
fn noop_visit( fn walk(
&mut self, &mut self,
ctxt: Option<AssocCtxt>, ctxt: Option<AssocCtxt>,
ident: Ident, ident: Ident,
@ -1258,7 +1252,7 @@ impl NoopVisitItemKind for AssocItemKind {
visitor.visit_generics(generics); visitor.visit_generics(generics);
visit_bounds(bounds, BoundKind::Bound, visitor); visit_bounds(bounds, BoundKind::Bound, visitor);
visit_opt(ty, |ty| visitor.visit_ty(ty)); visit_opt(ty, |ty| visitor.visit_ty(ty));
noop_visit_ty_alias_where_clauses(where_clauses, visitor); walk_ty_alias_where_clauses(where_clauses, visitor);
} }
AssocItemKind::MacCall(mac) => visitor.visit_mac_call(mac), AssocItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
AssocItemKind::Delegation(box Delegation { AssocItemKind::Delegation(box Delegation {
@ -1308,14 +1302,14 @@ fn visit_const_item<T: MutVisitor>(
visit_opt(expr, |expr| visitor.visit_expr(expr)); visit_opt(expr, |expr| visitor.visit_expr(expr));
} }
fn noop_visit_fn_header<T: MutVisitor>(header: &mut FnHeader, vis: &mut T) { fn walk_fn_header<T: MutVisitor>(header: &mut FnHeader, vis: &mut T) {
let FnHeader { safety, coroutine_kind, constness, ext: _ } = header; let FnHeader { safety, coroutine_kind, constness, ext: _ } = header;
visit_constness(constness, vis); visit_constness(constness, vis);
coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind)); coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
visit_safety(safety, vis); visit_safety(safety, vis);
} }
pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) { pub fn walk_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
let Crate { attrs, items, spans, id, is_placeholder: _ } = krate; let Crate { attrs, items, spans, id, is_placeholder: _ } = krate;
vis.visit_id(id); vis.visit_id(id);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
@ -1326,7 +1320,7 @@ pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
} }
/// Mutates one item, returning the item again. /// Mutates one item, returning the item again.
pub fn noop_flat_map_item<K: NoopVisitItemKind>( pub fn walk_flat_map_item<K: NoopVisitItemKind>(
mut item: P<Item<K>>, mut item: P<Item<K>>,
ctxt: Option<AssocCtxt>, ctxt: Option<AssocCtxt>,
visitor: &mut impl MutVisitor, visitor: &mut impl MutVisitor,
@ -1336,14 +1330,14 @@ pub fn noop_flat_map_item<K: NoopVisitItemKind>(
visit_attrs(attrs, visitor); visit_attrs(attrs, visitor);
visitor.visit_vis(vis); visitor.visit_vis(vis);
visitor.visit_ident(ident); visitor.visit_ident(ident);
kind.noop_visit(ctxt, *ident, *span, *id, visitor); kind.walk(ctxt, *ident, *span, *id, visitor);
visit_lazy_tts(tokens, visitor); visit_lazy_tts(tokens, visitor);
visitor.visit_span(span); visitor.visit_span(span);
smallvec![item] smallvec![item]
} }
impl NoopVisitItemKind for ForeignItemKind { impl NoopVisitItemKind for ForeignItemKind {
fn noop_visit( fn walk(
&mut self, &mut self,
ctxt: Option<AssocCtxt>, ctxt: Option<AssocCtxt>,
ident: Ident, ident: Ident,
@ -1372,14 +1366,14 @@ impl NoopVisitItemKind for ForeignItemKind {
visitor.visit_generics(generics); visitor.visit_generics(generics);
visit_bounds(bounds, BoundKind::Bound, visitor); visit_bounds(bounds, BoundKind::Bound, visitor);
visit_opt(ty, |ty| visitor.visit_ty(ty)); visit_opt(ty, |ty| visitor.visit_ty(ty));
noop_visit_ty_alias_where_clauses(where_clauses, visitor); walk_ty_alias_where_clauses(where_clauses, visitor);
} }
ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac), ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
} }
} }
} }
pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) { pub fn walk_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
let Pat { id, kind, span, tokens } = pat.deref_mut(); let Pat { id, kind, span, tokens } = pat.deref_mut();
vis.visit_id(id); vis.visit_id(id);
match kind { match kind {
@ -1422,12 +1416,12 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_anon_const<T: MutVisitor>(AnonConst { id, value }: &mut AnonConst, vis: &mut T) { fn walk_anon_const<T: MutVisitor>(AnonConst { id, value }: &mut AnonConst, vis: &mut T) {
vis.visit_id(id); vis.visit_id(id);
vis.visit_expr(value); vis.visit_expr(value);
} }
fn noop_visit_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) { fn walk_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) {
// FIXME: Visit spans inside all this currently ignored stuff. // FIXME: Visit spans inside all this currently ignored stuff.
let InlineAsm { let InlineAsm {
template: _, template: _,
@ -1457,7 +1451,7 @@ fn noop_visit_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) {
} }
} }
fn noop_visit_inline_asm_sym<T: MutVisitor>( fn walk_inline_asm_sym<T: MutVisitor>(
InlineAsmSym { id, qself, path }: &mut InlineAsmSym, InlineAsmSym { id, qself, path }: &mut InlineAsmSym,
vis: &mut T, vis: &mut T,
) { ) {
@ -1466,7 +1460,7 @@ fn noop_visit_inline_asm_sym<T: MutVisitor>(
vis.visit_path(path); vis.visit_path(path);
} }
fn noop_visit_format_args<T: MutVisitor>(fmt: &mut FormatArgs, vis: &mut T) { fn walk_format_args<T: MutVisitor>(fmt: &mut FormatArgs, vis: &mut T) {
// FIXME: visit the template exhaustively. // FIXME: visit the template exhaustively.
let FormatArgs { span, template: _, arguments } = fmt; let FormatArgs { span, template: _, arguments } = fmt;
for FormatArgument { kind, expr } in arguments.all_args_mut() { for FormatArgument { kind, expr } in arguments.all_args_mut() {
@ -1481,10 +1475,7 @@ fn noop_visit_format_args<T: MutVisitor>(fmt: &mut FormatArgs, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
pub fn noop_visit_expr<T: MutVisitor>( pub fn walk_expr<T: MutVisitor>(Expr { kind, id, span, attrs, tokens }: &mut Expr, vis: &mut T) {
Expr { kind, id, span, attrs, tokens }: &mut Expr,
vis: &mut T,
) {
vis.visit_id(id); vis.visit_id(id);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
match kind { match kind {
@ -1673,12 +1664,12 @@ pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Optio
}) })
} }
pub fn noop_flat_map_stmt<T: MutVisitor>( pub fn walk_flat_map_stmt<T: MutVisitor>(
Stmt { kind, mut span, mut id }: Stmt, Stmt { kind, mut span, mut id }: Stmt,
vis: &mut T, vis: &mut T,
) -> SmallVec<[Stmt; 1]> { ) -> SmallVec<[Stmt; 1]> {
vis.visit_id(&mut id); vis.visit_id(&mut id);
let stmts: SmallVec<_> = noop_flat_map_stmt_kind(kind, vis) let stmts: SmallVec<_> = walk_flat_map_stmt_kind(kind, vis)
.into_iter() .into_iter()
.map(|kind| Stmt { id, kind, span }) .map(|kind| Stmt { id, kind, span })
.collect(); .collect();
@ -1692,7 +1683,7 @@ pub fn noop_flat_map_stmt<T: MutVisitor>(
stmts stmts
} }
fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) -> SmallVec<[StmtKind; 1]> { fn walk_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) -> SmallVec<[StmtKind; 1]> {
match kind { match kind {
StmtKind::Let(mut local) => smallvec![StmtKind::Let({ StmtKind::Let(mut local) => smallvec![StmtKind::Let({
vis.visit_local(&mut local); vis.visit_local(&mut local);
@ -1712,7 +1703,7 @@ fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) -> SmallV
} }
} }
fn noop_visit_vis<T: MutVisitor>(visibility: &mut Visibility, vis: &mut T) { fn walk_vis<T: MutVisitor>(visibility: &mut Visibility, vis: &mut T) {
let Visibility { kind, span, tokens } = visibility; let Visibility { kind, span, tokens } = visibility;
match kind { match kind {
VisibilityKind::Public | VisibilityKind::Inherited => {} VisibilityKind::Public | VisibilityKind::Inherited => {}
@ -1725,7 +1716,7 @@ fn noop_visit_vis<T: MutVisitor>(visibility: &mut Visibility, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
fn noop_visit_capture_by<T: MutVisitor>(capture_by: &mut CaptureBy, vis: &mut T) { fn walk_capture_by<T: MutVisitor>(capture_by: &mut CaptureBy, vis: &mut T) {
match capture_by { match capture_by {
CaptureBy::Ref => {} CaptureBy::Ref => {}
CaptureBy::Value { move_kw } => { CaptureBy::Value { move_kw } => {

28
compiler/rustc_builtin_macros/src/cfg_eval.rs
View file

@ -212,18 +212,18 @@ impl MutVisitor for CfgEval<'_> {
#[instrument(level = "trace", skip(self))] #[instrument(level = "trace", skip(self))]
fn visit_expr(&mut self, expr: &mut P<ast::Expr>) { fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
self.0.configure_expr(expr, false); self.0.configure_expr(expr, false);
mut_visit::noop_visit_expr(expr, self); mut_visit::walk_expr(expr, self);
} }
#[instrument(level = "trace", skip(self))] #[instrument(level = "trace", skip(self))]
fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) { fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) {
self.0.configure_expr(expr, true); self.0.configure_expr(expr, true);
mut_visit::noop_visit_expr(expr, self); mut_visit::walk_expr(expr, self);
} }
fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> { fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
let mut expr = configure!(self, expr); let mut expr = configure!(self, expr);
mut_visit::noop_visit_expr(&mut expr, self); mut_visit::walk_expr(&mut expr, self);
Some(expr) Some(expr)
} }
@ -231,15 +231,15 @@ impl MutVisitor for CfgEval<'_> {
&mut self, &mut self,
param: ast::GenericParam, param: ast::GenericParam,
) -> SmallVec<[ast::GenericParam; 1]> { ) -> SmallVec<[ast::GenericParam; 1]> {
mut_visit::noop_flat_map_generic_param(configure!(self, param), self) mut_visit::walk_flat_map_generic_param(configure!(self, param), self)
} }
fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
mut_visit::noop_flat_map_stmt(configure!(self, stmt), self) mut_visit::walk_flat_map_stmt(configure!(self, stmt), self)
} }
fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> { fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
mut_visit::noop_flat_map_item(configure!(self, item), None, self) mut_visit::walk_flat_map_item(configure!(self, item), None, self)
} }
fn flat_map_assoc_item( fn flat_map_assoc_item(
@ -247,37 +247,37 @@ impl MutVisitor for CfgEval<'_> {
item: P<ast::AssocItem>, item: P<ast::AssocItem>,
ctxt: AssocCtxt, ctxt: AssocCtxt,
) -> SmallVec<[P<ast::AssocItem>; 1]> { ) -> SmallVec<[P<ast::AssocItem>; 1]> {
mut_visit::noop_flat_map_item(configure!(self, item), Some(ctxt), self) mut_visit::walk_flat_map_item(configure!(self, item), Some(ctxt), self)
} }
fn flat_map_foreign_item( fn flat_map_foreign_item(
&mut self, &mut self,
foreign_item: P<ast::ForeignItem>, foreign_item: P<ast::ForeignItem>,
) -> SmallVec<[P<ast::ForeignItem>; 1]> { ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
mut_visit::noop_flat_map_item(configure!(self, foreign_item), None, self) mut_visit::walk_flat_map_item(configure!(self, foreign_item), None, self)
} }
fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> { fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
mut_visit::noop_flat_map_arm(configure!(self, arm), self) mut_visit::walk_flat_map_arm(configure!(self, arm), self)
} }
fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> { fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
mut_visit::noop_flat_map_expr_field(configure!(self, field), self) mut_visit::walk_flat_map_expr_field(configure!(self, field), self)
} }
fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> { fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
mut_visit::noop_flat_map_pat_field(configure!(self, fp), self) mut_visit::walk_flat_map_pat_field(configure!(self, fp), self)
} }
fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> { fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
mut_visit::noop_flat_map_param(configure!(self, p), self) mut_visit::walk_flat_map_param(configure!(self, p), self)
} }
fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> { fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
mut_visit::noop_flat_map_field_def(configure!(self, sf), self) mut_visit::walk_flat_map_field_def(configure!(self, sf), self)
} }
fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> { fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
mut_visit::noop_flat_map_variant(configure!(self, variant), self) mut_visit::walk_flat_map_variant(configure!(self, variant), self)
} }
} }

6
compiler/rustc_builtin_macros/src/test_harness.rs
View file

@ -122,7 +122,7 @@ impl TestHarnessGenerator<'_> {
impl<'a> MutVisitor for TestHarnessGenerator<'a> { impl<'a> MutVisitor for TestHarnessGenerator<'a> {
fn visit_crate(&mut self, c: &mut ast::Crate) { fn visit_crate(&mut self, c: &mut ast::Crate) {
let prev_tests = mem::take(&mut self.tests); let prev_tests = mem::take(&mut self.tests);
noop_visit_crate(c, self); walk_crate(c, self);
self.add_test_cases(ast::CRATE_NODE_ID, c.spans.inner_span, prev_tests); self.add_test_cases(ast::CRATE_NODE_ID, c.spans.inner_span, prev_tests);
// Create a main function to run our tests // Create a main function to run our tests
@ -144,7 +144,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
item.kind item.kind
{ {
let prev_tests = mem::take(&mut self.tests); let prev_tests = mem::take(&mut self.tests);
noop_visit_item_kind(&mut item.kind, item.ident, item.span, item.id, self); walk_item_kind(&mut item.kind, item.ident, item.span, item.id, self);
self.add_test_cases(item.id, span, prev_tests); self.add_test_cases(item.id, span, prev_tests);
} else { } else {
// But in those cases, we emit a lint to warn the user of these missing tests. // But in those cases, we emit a lint to warn the user of these missing tests.
@ -192,7 +192,7 @@ struct EntryPointCleaner<'a> {
impl<'a> MutVisitor for EntryPointCleaner<'a> { impl<'a> MutVisitor for EntryPointCleaner<'a> {
fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> { fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
self.depth += 1; self.depth += 1;
let item = noop_flat_map_item(i, None, self).expect_one("noop did something"); let item = walk_flat_map_item(i, None, self).expect_one("noop did something");
self.depth -= 1; self.depth -= 1;
// Remove any #[rustc_main] or #[start] from the AST so it doesn't // Remove any #[rustc_main] or #[start] from the AST so it doesn't

108
compiler/rustc_expand/src/expand.rs
View file

@ -1036,7 +1036,7 @@ pub(crate) fn ensure_complete_parse<'a>(
} }
} }
/// Wraps a call to `noop_visit_*` / `noop_flat_map_*` /// Wraps a call to `walk_*` / `walk_flat_map_*`
/// for an AST node that supports attributes /// for an AST node that supports attributes
/// (see the `Annotatable` enum) /// (see the `Annotatable` enum)
/// This method assigns a `NodeId`, and sets that `NodeId` /// This method assigns a `NodeId`, and sets that `NodeId`
@ -1056,7 +1056,7 @@ pub(crate) fn ensure_complete_parse<'a>(
/// * `id` is a mutable reference to the `NodeId` field /// * `id` is a mutable reference to the `NodeId` field
/// of the current AST node. /// of the current AST node.
/// * `closure` is a closure that executes the /// * `closure` is a closure that executes the
/// `noop_visit_*` / `noop_flat_map_*` method /// `walk_*` / `walk_flat_map_*` method
/// for the current AST node. /// for the current AST node.
macro_rules! assign_id { macro_rules! assign_id {
($self:ident, $id:expr, $closure:expr) => {{ ($self:ident, $id:expr, $closure:expr) => {{
@ -1090,10 +1090,10 @@ trait InvocationCollectorNode: HasAttrs + HasNodeId + Sized {
fn descr() -> &'static str { fn descr() -> &'static str {
unreachable!() unreachable!()
} }
fn noop_flat_map<V: MutVisitor>(self, _visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, _visitor: &mut V) -> Self::OutputTy {
unreachable!() unreachable!()
} }
fn noop_visit<V: MutVisitor>(&mut self, _visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, _visitor: &mut V) {
unreachable!() unreachable!()
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
@ -1117,12 +1117,12 @@ trait InvocationCollectorNode: HasAttrs + HasNodeId + Sized {
fn pre_flat_map_node_collect_attr(_cfg: &StripUnconfigured<'_>, _attr: &ast::Attribute) {} fn pre_flat_map_node_collect_attr(_cfg: &StripUnconfigured<'_>, _attr: &ast::Attribute) {}
fn post_flat_map_node_collect_bang(_output: &mut Self::OutputTy, _add_semicolon: AddSemicolon) { fn post_flat_map_node_collect_bang(_output: &mut Self::OutputTy, _add_semicolon: AddSemicolon) {
} }
fn wrap_flat_map_node_noop_flat_map( fn wrap_flat_map_node_walk_flat_map(
node: Self, node: Self,
collector: &mut InvocationCollector<'_, '_>, collector: &mut InvocationCollector<'_, '_>,
noop_flat_map: impl FnOnce(Self, &mut InvocationCollector<'_, '_>) -> Self::OutputTy, walk_flat_map: impl FnOnce(Self, &mut InvocationCollector<'_, '_>) -> Self::OutputTy,
) -> Result<Self::OutputTy, Self> { ) -> Result<Self::OutputTy, Self> {
Ok(noop_flat_map(node, collector)) Ok(walk_flat_map(node, collector))
} }
fn expand_cfg_false( fn expand_cfg_false(
&mut self, &mut self,
@ -1148,8 +1148,8 @@ impl InvocationCollectorNode for P<ast::Item> {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_items() fragment.make_items()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_item(self, None, visitor) walk_flat_map_item(self, None, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.kind, ItemKind::MacCall(..)) matches!(self.kind, ItemKind::MacCall(..))
@ -1176,13 +1176,13 @@ impl InvocationCollectorNode for P<ast::Item> {
fn flatten_outputs(items: impl Iterator<Item = Self::OutputTy>) -> Self::OutputTy { fn flatten_outputs(items: impl Iterator<Item = Self::OutputTy>) -> Self::OutputTy {
items.flatten().collect() items.flatten().collect()
} }
fn wrap_flat_map_node_noop_flat_map( fn wrap_flat_map_node_walk_flat_map(
mut node: Self, mut node: Self,
collector: &mut InvocationCollector<'_, '_>, collector: &mut InvocationCollector<'_, '_>,
noop_flat_map: impl FnOnce(Self, &mut InvocationCollector<'_, '_>) -> Self::OutputTy, walk_flat_map: impl FnOnce(Self, &mut InvocationCollector<'_, '_>) -> Self::OutputTy,
) -> Result<Self::OutputTy, Self> { ) -> Result<Self::OutputTy, Self> {
if !matches!(node.kind, ItemKind::Mod(..)) { if !matches!(node.kind, ItemKind::Mod(..)) {
return Ok(noop_flat_map(node, collector)); return Ok(walk_flat_map(node, collector));
} }
// Work around borrow checker not seeing through `P`'s deref. // Work around borrow checker not seeing through `P`'s deref.
@ -1252,7 +1252,7 @@ impl InvocationCollectorNode for P<ast::Item> {
let orig_dir_ownership = let orig_dir_ownership =
mem::replace(&mut ecx.current_expansion.dir_ownership, dir_ownership); mem::replace(&mut ecx.current_expansion.dir_ownership, dir_ownership);
let res = Ok(noop_flat_map(node, collector)); let res = Ok(walk_flat_map(node, collector));
collector.cx.current_expansion.dir_ownership = orig_dir_ownership; collector.cx.current_expansion.dir_ownership = orig_dir_ownership;
collector.cx.current_expansion.module = orig_module; collector.cx.current_expansion.module = orig_module;
@ -1292,8 +1292,8 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::AssocItem>, TraitItemTag>
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_trait_items() fragment.make_trait_items()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_item(self.wrapped, Some(AssocCtxt::Trait), visitor) walk_flat_map_item(self.wrapped, Some(AssocCtxt::Trait), visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, AssocItemKind::MacCall(..)) matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@ -1333,8 +1333,8 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::AssocItem>, ImplItemTag>
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_impl_items() fragment.make_impl_items()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_item(self.wrapped, Some(AssocCtxt::Impl), visitor) walk_flat_map_item(self.wrapped, Some(AssocCtxt::Impl), visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, AssocItemKind::MacCall(..)) matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@ -1371,8 +1371,8 @@ impl InvocationCollectorNode for P<ast::ForeignItem> {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_foreign_items() fragment.make_foreign_items()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_item(self, None, visitor) walk_flat_map_item(self, None, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.kind, ForeignItemKind::MacCall(..)) matches!(self.kind, ForeignItemKind::MacCall(..))
@ -1394,8 +1394,8 @@ impl InvocationCollectorNode for ast::Variant {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_variants() fragment.make_variants()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_variant(self, visitor) walk_flat_map_variant(self, visitor)
} }
} }
@ -1407,8 +1407,8 @@ impl InvocationCollectorNode for ast::FieldDef {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_field_defs() fragment.make_field_defs()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_field_def(self, visitor) walk_flat_map_field_def(self, visitor)
} }
} }
@ -1420,8 +1420,8 @@ impl InvocationCollectorNode for ast::PatField {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_pat_fields() fragment.make_pat_fields()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_pat_field(self, visitor) walk_flat_map_pat_field(self, visitor)
} }
} }
@ -1433,8 +1433,8 @@ impl InvocationCollectorNode for ast::ExprField {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_expr_fields() fragment.make_expr_fields()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_expr_field(self, visitor) walk_flat_map_expr_field(self, visitor)
} }
} }
@ -1446,8 +1446,8 @@ impl InvocationCollectorNode for ast::Param {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_params() fragment.make_params()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_param(self, visitor) walk_flat_map_param(self, visitor)
} }
} }
@ -1459,8 +1459,8 @@ impl InvocationCollectorNode for ast::GenericParam {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_generic_params() fragment.make_generic_params()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_generic_param(self, visitor) walk_flat_map_generic_param(self, visitor)
} }
} }
@ -1472,8 +1472,8 @@ impl InvocationCollectorNode for ast::Arm {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_arms() fragment.make_arms()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_arm(self, visitor) walk_flat_map_arm(self, visitor)
} }
} }
@ -1486,8 +1486,8 @@ impl InvocationCollectorNode for ast::Stmt {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_stmts() fragment.make_stmts()
} }
fn noop_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
noop_flat_map_stmt(self, visitor) walk_flat_map_stmt(self, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
match &self.kind { match &self.kind {
@ -1560,8 +1560,8 @@ impl InvocationCollectorNode for ast::Crate {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_crate() fragment.make_crate()
} }
fn noop_visit<V: MutVisitor>(&mut self, visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
noop_visit_crate(self, visitor) walk_crate(self, visitor)
} }
fn expand_cfg_false( fn expand_cfg_false(
&mut self, &mut self,
@ -1586,8 +1586,8 @@ impl InvocationCollectorNode for P<ast::Ty> {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_ty() fragment.make_ty()
} }
fn noop_visit<V: MutVisitor>(&mut self, visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
noop_visit_ty(self, visitor) walk_ty(self, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.kind, ast::TyKind::MacCall(..)) matches!(self.kind, ast::TyKind::MacCall(..))
@ -1610,8 +1610,8 @@ impl InvocationCollectorNode for P<ast::Pat> {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_pat() fragment.make_pat()
} }
fn noop_visit<V: MutVisitor>(&mut self, visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
noop_visit_pat(self, visitor) walk_pat(self, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.kind, PatKind::MacCall(..)) matches!(self.kind, PatKind::MacCall(..))
@ -1638,8 +1638,8 @@ impl InvocationCollectorNode for P<ast::Expr> {
fn descr() -> &'static str { fn descr() -> &'static str {
"an expression" "an expression"
} }
fn noop_visit<V: MutVisitor>(&mut self, visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
noop_visit_expr(self, visitor) walk_expr(self, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.kind, ExprKind::MacCall(..)) matches!(self.kind, ExprKind::MacCall(..))
@ -1664,8 +1664,8 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::Expr>, OptExprTag> {
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_opt_expr() fragment.make_opt_expr()
} }
fn noop_flat_map<V: MutVisitor>(mut self, visitor: &mut V) -> Self::OutputTy { fn walk_flat_map<V: MutVisitor>(mut self, visitor: &mut V) -> Self::OutputTy {
noop_visit_expr(&mut self.wrapped, visitor); walk_expr(&mut self.wrapped, visitor);
Some(self.wrapped) Some(self.wrapped)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
@ -1704,8 +1704,8 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::Expr>, MethodReceiverTag>
fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy { fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
AstNodeWrapper::new(fragment.make_method_receiver_expr(), MethodReceiverTag) AstNodeWrapper::new(fragment.make_method_receiver_expr(), MethodReceiverTag)
} }
fn noop_visit<V: MutVisitor>(&mut self, visitor: &mut V) { fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
noop_visit_expr(&mut self.wrapped, visitor) walk_expr(&mut self.wrapped, visitor)
} }
fn is_mac_call(&self) -> bool { fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, ast::ExprKind::MacCall(..)) matches!(self.wrapped.kind, ast::ExprKind::MacCall(..))
@ -2015,12 +2015,12 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
); );
Node::flatten_outputs(single_delegations.map(|item| { Node::flatten_outputs(single_delegations.map(|item| {
let mut item = Node::from_item(item); let mut item = Node::from_item(item);
assign_id!(self, item.node_id_mut(), || item.noop_flat_map(self)) assign_id!(self, item.node_id_mut(), || item.walk_flat_map(self))
})) }))
} }
None => { None => {
match Node::wrap_flat_map_node_noop_flat_map(node, self, |mut node, this| { match Node::wrap_flat_map_node_walk_flat_map(node, self, |mut node, this| {
assign_id!(this, node.node_id_mut(), || node.noop_flat_map(this)) assign_id!(this, node.node_id_mut(), || node.walk_flat_map(this))
}) { }) {
Ok(output) => output, Ok(output) => output,
Err(returned_node) => { Err(returned_node) => {
@ -2068,7 +2068,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
} }
None if node.delegation().is_some() => unreachable!(), None if node.delegation().is_some() => unreachable!(),
None => { None => {
assign_id!(self, node.node_id_mut(), || node.noop_visit(self)) assign_id!(self, node.node_id_mut(), || node.walk(self))
} }
}; };
} }
@ -2147,11 +2147,11 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
self.cx.current_expansion.is_trailing_mac = true; self.cx.current_expansion.is_trailing_mac = true;
// Don't use `assign_id` for this statement - it may get removed // Don't use `assign_id` for this statement - it may get removed
// entirely due to a `#[cfg]` on the contained expression // entirely due to a `#[cfg]` on the contained expression
let res = noop_flat_map_stmt(node, self); let res = walk_flat_map_stmt(node, self);
self.cx.current_expansion.is_trailing_mac = false; self.cx.current_expansion.is_trailing_mac = false;
res res
} }
_ => noop_flat_map_stmt(node, self), _ => walk_flat_map_stmt(node, self),
}; };
} }
@ -2195,7 +2195,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
&mut self.cx.current_expansion.dir_ownership, &mut self.cx.current_expansion.dir_ownership,
DirOwnership::UnownedViaBlock, DirOwnership::UnownedViaBlock,
); );
noop_visit_block(node, self); walk_block(node, self);
self.cx.current_expansion.dir_ownership = orig_dir_ownership; self.cx.current_expansion.dir_ownership = orig_dir_ownership;
} }

32
compiler/rustc_expand/src/placeholders.rs
View file

@ -209,7 +209,7 @@ impl MutVisitor for PlaceholderExpander {
if arm.is_placeholder { if arm.is_placeholder {
self.remove(arm.id).make_arms() self.remove(arm.id).make_arms()
} else { } else {
noop_flat_map_arm(arm, self) walk_flat_map_arm(arm, self)
} }
} }
@ -217,7 +217,7 @@ impl MutVisitor for PlaceholderExpander {
if field.is_placeholder { if field.is_placeholder {
self.remove(field.id).make_expr_fields() self.remove(field.id).make_expr_fields()
} else { } else {
noop_flat_map_expr_field(field, self) walk_flat_map_expr_field(field, self)
} }
} }
@ -225,7 +225,7 @@ impl MutVisitor for PlaceholderExpander {
if fp.is_placeholder { if fp.is_placeholder {
self.remove(fp.id).make_pat_fields() self.remove(fp.id).make_pat_fields()
} else { } else {
noop_flat_map_pat_field(fp, self) walk_flat_map_pat_field(fp, self)
} }
} }
@ -236,7 +236,7 @@ impl MutVisitor for PlaceholderExpander {
if param.is_placeholder { if param.is_placeholder {
self.remove(param.id).make_generic_params() self.remove(param.id).make_generic_params()
} else { } else {
noop_flat_map_generic_param(param, self) walk_flat_map_generic_param(param, self)
} }
} }
@ -244,7 +244,7 @@ impl MutVisitor for PlaceholderExpander {
if p.is_placeholder { if p.is_placeholder {
self.remove(p.id).make_params() self.remove(p.id).make_params()
} else { } else {
noop_flat_map_param(p, self) walk_flat_map_param(p, self)
} }
} }
@ -252,7 +252,7 @@ impl MutVisitor for PlaceholderExpander {
if sf.is_placeholder { if sf.is_placeholder {
self.remove(sf.id).make_field_defs() self.remove(sf.id).make_field_defs()
} else { } else {
noop_flat_map_field_def(sf, self) walk_flat_map_field_def(sf, self)
} }
} }
@ -260,14 +260,14 @@ impl MutVisitor for PlaceholderExpander {
if variant.is_placeholder { if variant.is_placeholder {
self.remove(variant.id).make_variants() self.remove(variant.id).make_variants()
} else { } else {
noop_flat_map_variant(variant, self) walk_flat_map_variant(variant, self)
} }
} }
fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> { fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
match item.kind { match item.kind {
ast::ItemKind::MacCall(_) => self.remove(item.id).make_items(), ast::ItemKind::MacCall(_) => self.remove(item.id).make_items(),
_ => noop_flat_map_item(item, None, self), _ => walk_flat_map_item(item, None, self),
} }
} }
@ -284,7 +284,7 @@ impl MutVisitor for PlaceholderExpander {
AssocCtxt::Impl => it.make_impl_items(), AssocCtxt::Impl => it.make_impl_items(),
} }
} }
_ => noop_flat_map_item(item, Some(ctxt), self), _ => walk_flat_map_item(item, Some(ctxt), self),
} }
} }
@ -294,21 +294,21 @@ impl MutVisitor for PlaceholderExpander {
) -> SmallVec<[P<ast::ForeignItem>; 1]> { ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
match item.kind { match item.kind {
ast::ForeignItemKind::MacCall(_) => self.remove(item.id).make_foreign_items(), ast::ForeignItemKind::MacCall(_) => self.remove(item.id).make_foreign_items(),
_ => noop_flat_map_item(item, None, self), _ => walk_flat_map_item(item, None, self),
} }
} }
fn visit_expr(&mut self, expr: &mut P<ast::Expr>) { fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
match expr.kind { match expr.kind {
ast::ExprKind::MacCall(_) => *expr = self.remove(expr.id).make_expr(), ast::ExprKind::MacCall(_) => *expr = self.remove(expr.id).make_expr(),
_ => noop_visit_expr(expr, self), _ => walk_expr(expr, self),
} }
} }
fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) { fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) {
match expr.kind { match expr.kind {
ast::ExprKind::MacCall(_) => *expr = self.remove(expr.id).make_method_receiver_expr(), ast::ExprKind::MacCall(_) => *expr = self.remove(expr.id).make_method_receiver_expr(),
_ => noop_visit_expr(expr, self), _ => walk_expr(expr, self),
} }
} }
@ -322,7 +322,7 @@ impl MutVisitor for PlaceholderExpander {
fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
let (style, mut stmts) = match stmt.kind { let (style, mut stmts) = match stmt.kind {
ast::StmtKind::MacCall(mac) => (mac.style, self.remove(stmt.id).make_stmts()), ast::StmtKind::MacCall(mac) => (mac.style, self.remove(stmt.id).make_stmts()),
_ => return noop_flat_map_stmt(stmt, self), _ => return walk_flat_map_stmt(stmt, self),
}; };
if style == ast::MacStmtStyle::Semicolon { if style == ast::MacStmtStyle::Semicolon {
@ -368,14 +368,14 @@ impl MutVisitor for PlaceholderExpander {
fn visit_pat(&mut self, pat: &mut P<ast::Pat>) { fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
match pat.kind { match pat.kind {
ast::PatKind::MacCall(_) => *pat = self.remove(pat.id).make_pat(), ast::PatKind::MacCall(_) => *pat = self.remove(pat.id).make_pat(),
_ => noop_visit_pat(pat, self), _ => walk_pat(pat, self),
} }
} }
fn visit_ty(&mut self, ty: &mut P<ast::Ty>) { fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
match ty.kind { match ty.kind {
ast::TyKind::MacCall(_) => *ty = self.remove(ty.id).make_ty(), ast::TyKind::MacCall(_) => *ty = self.remove(ty.id).make_ty(),
_ => noop_visit_ty(ty, self), _ => walk_ty(ty, self),
} }
} }
@ -383,7 +383,7 @@ impl MutVisitor for PlaceholderExpander {
if krate.is_placeholder { if krate.is_placeholder {
*krate = self.remove(krate.id).make_crate(); *krate = self.remove(krate.id).make_crate();
} else { } else {
noop_visit_crate(krate, self) walk_crate(krate, self)
} }
} }
} }

12
compiler/rustc_parse/src/parser/expr.rs
View file

@ -10,7 +10,7 @@ use super::{
use crate::errors; use crate::errors;
use crate::maybe_recover_from_interpolated_ty_qpath; use crate::maybe_recover_from_interpolated_ty_qpath;
use ast::mut_visit::{noop_visit_expr, MutVisitor}; use ast::mut_visit::{self, MutVisitor};
use ast::token::IdentIsRaw; use ast::token::IdentIsRaw;
use ast::{CoroutineKind, ForLoopKind, GenBlockKind, MatchKind, Pat, Path, PathSegment, Recovered}; use ast::{CoroutineKind, ForLoopKind, GenBlockKind, MatchKind, Pat, Path, PathSegment, Recovered};
use core::mem; use core::mem;
@ -3939,14 +3939,14 @@ impl MutVisitor for CondChecker<'_> {
} }
} }
ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => { ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => {
noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
} }
ExprKind::Binary(Spanned { node: BinOpKind::Or, span: or_span }, _, _) ExprKind::Binary(Spanned { node: BinOpKind::Or, span: or_span }, _, _)
if let None | Some(NotSupportedOr(_)) = self.forbid_let_reason => if let None | Some(NotSupportedOr(_)) = self.forbid_let_reason =>
{ {
let forbid_let_reason = self.forbid_let_reason; let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(NotSupportedOr(or_span)); self.forbid_let_reason = Some(NotSupportedOr(or_span));
noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
self.forbid_let_reason = forbid_let_reason; self.forbid_let_reason = forbid_let_reason;
} }
ExprKind::Paren(ref inner) ExprKind::Paren(ref inner)
@ -3954,7 +3954,7 @@ impl MutVisitor for CondChecker<'_> {
{ {
let forbid_let_reason = self.forbid_let_reason; let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(NotSupportedParentheses(inner.span)); self.forbid_let_reason = Some(NotSupportedParentheses(inner.span));
noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
self.forbid_let_reason = forbid_let_reason; self.forbid_let_reason = forbid_let_reason;
} }
ExprKind::Assign(ref lhs, _, span) => { ExprKind::Assign(ref lhs, _, span) => {
@ -3972,7 +3972,7 @@ impl MutVisitor for CondChecker<'_> {
} }
let comparison = self.comparison; let comparison = self.comparison;
self.comparison = Some(errors::MaybeComparison { span: span.shrink_to_hi() }); self.comparison = Some(errors::MaybeComparison { span: span.shrink_to_hi() });
noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
self.forbid_let_reason = forbid_let_reason; self.forbid_let_reason = forbid_let_reason;
self.missing_let = missing_let; self.missing_let = missing_let;
self.comparison = comparison; self.comparison = comparison;
@ -3992,7 +3992,7 @@ impl MutVisitor for CondChecker<'_> {
| ExprKind::Paren(_) => { | ExprKind::Paren(_) => {
let forbid_let_reason = self.forbid_let_reason; let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(OtherForbidden); self.forbid_let_reason = Some(OtherForbidden);
noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
self.forbid_let_reason = forbid_let_reason; self.forbid_let_reason = forbid_let_reason;
} }
ExprKind::Cast(ref mut op, _) | ExprKind::Type(ref mut op, _) => { ExprKind::Cast(ref mut op, _) | ExprKind::Type(ref mut op, _) => {

4
compiler/rustc_parse/src/parser/pat.rs
View file

@ -12,7 +12,7 @@ use crate::errors::{
}; };
use crate::parser::expr::{could_be_unclosed_char_literal, LhsExpr}; use crate::parser::expr::{could_be_unclosed_char_literal, LhsExpr};
use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole}; use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
use rustc_ast::mut_visit::{noop_visit_pat, MutVisitor}; use rustc_ast::mut_visit::{walk_pat, MutVisitor};
use rustc_ast::ptr::P; use rustc_ast::ptr::P;
use rustc_ast::token::{self, BinOpToken, Delimiter, Token}; use rustc_ast::token::{self, BinOpToken, Delimiter, Token};
use rustc_ast::{ use rustc_ast::{
@ -810,7 +810,7 @@ impl<'a> Parser<'a> {
self.0 = true; self.0 = true;
*m = Mutability::Mut; *m = Mutability::Mut;
} }
noop_visit_pat(pat, self); walk_pat(pat, self);
} }
} }

8
src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs
View file

@ -121,7 +121,7 @@ fn remove_all_parens(pat: &mut P<Pat>) {
struct Visitor; struct Visitor;
impl MutVisitor for Visitor { impl MutVisitor for Visitor {
fn visit_pat(&mut self, pat: &mut P<Pat>) { fn visit_pat(&mut self, pat: &mut P<Pat>) {
noop_visit_pat(pat, self); walk_pat(pat, self);
let inner = match &mut pat.kind { let inner = match &mut pat.kind {
Paren(i) => mem::replace(&mut i.kind, Wild), Paren(i) => mem::replace(&mut i.kind, Wild),
_ => return, _ => return,
@ -138,7 +138,7 @@ fn insert_necessary_parens(pat: &mut P<Pat>) {
impl MutVisitor for Visitor { impl MutVisitor for Visitor {
fn visit_pat(&mut self, pat: &mut P<Pat>) { fn visit_pat(&mut self, pat: &mut P<Pat>) {
use ast::BindingMode; use ast::BindingMode;
noop_visit_pat(pat, self); walk_pat(pat, self);
let target = match &mut pat.kind { let target = match &mut pat.kind {
// `i @ a | b`, `box a | b`, and `& mut? a | b`. // `i @ a | b`, `box a | b`, and `& mut? a | b`.
Ident(.., Some(p)) | Box(p) | Ref(p, _) if matches!(&p.kind, Or(ps) if ps.len() > 1) => p, Ident(.., Some(p)) | Box(p) | Ref(p, _) if matches!(&p.kind, Or(ps) if ps.len() > 1) => p,
@ -160,7 +160,7 @@ fn unnest_or_patterns(pat: &mut P<Pat>) -> bool {
impl MutVisitor for Visitor { impl MutVisitor for Visitor {
fn visit_pat(&mut self, p: &mut P<Pat>) { fn visit_pat(&mut self, p: &mut P<Pat>) {
// This is a bottom up transformation, so recurse first. // This is a bottom up transformation, so recurse first.
noop_visit_pat(p, self); walk_pat(p, self);
// Don't have an or-pattern? Just quit early on. // Don't have an or-pattern? Just quit early on.
let Or(alternatives) = &mut p.kind else { return }; let Or(alternatives) = &mut p.kind else { return };
@ -189,7 +189,7 @@ fn unnest_or_patterns(pat: &mut P<Pat>) -> bool {
// Deal with `Some(Some(0)) | Some(Some(1))`. // Deal with `Some(Some(0)) | Some(Some(1))`.
if this_level_changed { if this_level_changed {
noop_visit_pat(p, self); walk_pat(p, self);
} }
} }
} }

4
tests/ui-fulldeps/pprust-expr-roundtrip.rs
View file

@ -202,7 +202,7 @@ impl MutVisitor for RemoveParens {
ExprKind::Paren(inner) => *e = inner, ExprKind::Paren(inner) => *e = inner,
_ => {} _ => {}
}; };
mut_visit::noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
} }
} }
@ -211,7 +211,7 @@ struct AddParens;
impl MutVisitor for AddParens { impl MutVisitor for AddParens {
fn visit_expr(&mut self, e: &mut P<Expr>) { fn visit_expr(&mut self, e: &mut P<Expr>) {
mut_visit::noop_visit_expr(e, self); mut_visit::walk_expr(e, self);
visit_clobber(e, |e| { visit_clobber(e, |e| {
P(Expr { P(Expr {
id: DUMMY_NODE_ID, id: DUMMY_NODE_ID,