mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Always pass the visitor as the first argument to walk* functions

Browse Source
This commit is contained in:
Oli Scherer 2024-07-17 11:23:35 +00:00
parent 754bdef793
commit 8d290058c9
10 changed files with 294 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

414
compiler/rustc_ast/src/mut_visit.rs
View File

File diff suppressed because it is too large Load Diff

39
compiler/rustc_builtin_macros/src/cfg_eval.rs
View File

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

4
compiler/rustc_builtin_macros/src/test_harness.rs
View File

@ -122,7 +122,7 @@ fn add_test_cases(&mut self, node_id: ast::NodeId, span: Span, prev_tests: Vec<T
impl<'a> MutVisitor for TestHarnessGenerator<'a> {
fn visit_crate(&mut self, c: &mut ast::Crate) {
let prev_tests = mem::take(&mut self.tests);
walk_crate(c, self);
walk_crate(self, c);
self.add_test_cases(ast::CRATE_NODE_ID, c.spans.inner_span, prev_tests);
// Create a main function to run our tests
@ -192,7 +192,7 @@ struct EntryPointCleaner<'a> {
impl<'a> MutVisitor for EntryPointCleaner<'a> {
fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
self.depth += 1;
let item = walk_flat_map_item(i, None, self).expect_one("noop did something");
let item = walk_flat_map_item(self, i, None).expect_one("noop did something");
self.depth -= 1;
// Remove any #[rustc_main] or #[start] from the AST so it doesn't

42
compiler/rustc_expand/src/expand.rs
View File

@ -1149,7 +1149,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_items()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_item(self, None, visitor)
walk_flat_map_item(visitor, self, None)
}
fn is_mac_call(&self) -> bool {
matches!(self.kind, ItemKind::MacCall(..))
@ -1293,7 +1293,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_trait_items()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_item(self.wrapped, Some(AssocCtxt::Trait), visitor)
walk_flat_map_item(visitor, self.wrapped, Some(AssocCtxt::Trait))
}
fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@ -1334,7 +1334,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_impl_items()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_item(self.wrapped, Some(AssocCtxt::Impl), visitor)
walk_flat_map_item(visitor, self.wrapped, Some(AssocCtxt::Impl))
}
fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, AssocItemKind::MacCall(..))
@ -1372,7 +1372,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_foreign_items()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_item(self, None, visitor)
walk_flat_map_item(visitor, self, None)
}
fn is_mac_call(&self) -> bool {
matches!(self.kind, ForeignItemKind::MacCall(..))
@ -1395,7 +1395,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_variants()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_variant(self, visitor)
walk_flat_map_variant(visitor, self)
}
}
@ -1408,7 +1408,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_field_defs()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_field_def(self, visitor)
walk_flat_map_field_def(visitor, self)
}
}
@ -1421,7 +1421,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_pat_fields()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_pat_field(self, visitor)
walk_flat_map_pat_field(visitor, self)
}
}
@ -1434,7 +1434,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_expr_fields()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_expr_field(self, visitor)
walk_flat_map_expr_field(visitor, self)
}
}
@ -1447,7 +1447,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_params()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_param(self, visitor)
walk_flat_map_param(visitor, self)
}
}
@ -1460,7 +1460,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_generic_params()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_generic_param(self, visitor)
walk_flat_map_generic_param(visitor, self)
}
}
@ -1473,7 +1473,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_arms()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_arm(self, visitor)
walk_flat_map_arm(visitor, self)
}
}
@ -1487,7 +1487,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_stmts()
}
fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
walk_flat_map_stmt(self, visitor)
walk_flat_map_stmt(visitor, self)
}
fn is_mac_call(&self) -> bool {
match &self.kind {
@ -1561,7 +1561,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_crate()
}
fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
walk_crate(self, visitor)
walk_crate(visitor, self)
}
fn expand_cfg_false(
&mut self,
@ -1587,7 +1587,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_ty()
}
fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
walk_ty(self, visitor)
walk_ty(visitor, self)
}
fn is_mac_call(&self) -> bool {
matches!(self.kind, ast::TyKind::MacCall(..))
@ -1611,7 +1611,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_pat()
}
fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
walk_pat(self, visitor)
walk_pat(visitor, self)
}
fn is_mac_call(&self) -> bool {
matches!(self.kind, PatKind::MacCall(..))
@ -1639,7 +1639,7 @@ fn descr() -> &'static str {
"an expression"
}
fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
walk_expr(self, visitor)
walk_expr(visitor, self)
}
fn is_mac_call(&self) -> bool {
matches!(self.kind, ExprKind::MacCall(..))
@ -1665,7 +1665,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
fragment.make_opt_expr()
}
fn walk_flat_map<V: MutVisitor>(mut self, visitor: &mut V) -> Self::OutputTy {
walk_expr(&mut self.wrapped, visitor);
walk_expr(visitor, &mut self.wrapped);
Some(self.wrapped)
}
fn is_mac_call(&self) -> bool {
@ -1705,7 +1705,7 @@ fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
AstNodeWrapper::new(fragment.make_method_receiver_expr(), MethodReceiverTag)
}
fn walk<V: MutVisitor>(&mut self, visitor: &mut V) {
walk_expr(&mut self.wrapped, visitor)
walk_expr(visitor, &mut self.wrapped)
}
fn is_mac_call(&self) -> bool {
matches!(self.wrapped.kind, ast::ExprKind::MacCall(..))
@ -2147,11 +2147,11 @@ fn flat_map_generic_param(
self.cx.current_expansion.is_trailing_mac = true;
// Don't use `assign_id` for this statement - it may get removed
// entirely due to a `#[cfg]` on the contained expression
let res = walk_flat_map_stmt(node, self);
let res = walk_flat_map_stmt(self, node);
self.cx.current_expansion.is_trailing_mac = false;
res
}
_ => walk_flat_map_stmt(node, self),
_ => walk_flat_map_stmt(self, node),
};
}
@ -2195,7 +2195,7 @@ fn visit_block(&mut self, node: &mut P<ast::Block>) {
&mut self.cx.current_expansion.dir_ownership,
DirOwnership::UnownedViaBlock,
);
walk_block(node, self);
walk_block(self, node);
self.cx.current_expansion.dir_ownership = orig_dir_ownership;
}

4
compiler/rustc_expand/src/mbe/transcribe.rs
View File

@ -333,7 +333,7 @@ pub(super) fn transcribe<'a>(
// jump back out of the Delimited, pop the result_stack and add the new results back to
// the previous results (from outside the Delimited).
mbe::TokenTree::Delimited(mut span, spacing, delimited) => {
mut_visit::visit_delim_span(&mut span, &mut marker);
mut_visit::visit_delim_span(&mut marker, &mut span);
stack.push(Frame::new_delimited(delimited, span, *spacing));
result_stack.push(mem::take(&mut result));
}
@ -342,7 +342,7 @@ pub(super) fn transcribe<'a>(
// preserve syntax context.
mbe::TokenTree::Token(token) => {
let mut token = token.clone();
mut_visit::visit_token(&mut token, &mut marker);
mut_visit::visit_token(&mut marker, &mut token);
let tt = TokenTree::Token(token, Spacing::Alone);
result.push(tt);
}

34
compiler/rustc_expand/src/placeholders.rs
View File

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

10
compiler/rustc_parse/src/parser/expr.rs
View File

@ -3939,14 +3939,14 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
}
}
ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => {
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
}
ExprKind::Binary(Spanned { node: BinOpKind::Or, span: or_span }, _, _)
if let None | Some(NotSupportedOr(_)) = self.forbid_let_reason =>
{
let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(NotSupportedOr(or_span));
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
self.forbid_let_reason = forbid_let_reason;
}
ExprKind::Paren(ref inner)
@ -3954,7 +3954,7 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
{
let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(NotSupportedParentheses(inner.span));
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
self.forbid_let_reason = forbid_let_reason;
}
ExprKind::Assign(ref lhs, _, span) => {
@ -3972,7 +3972,7 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
}
let comparison = self.comparison;
self.comparison = Some(errors::MaybeComparison { span: span.shrink_to_hi() });
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
self.forbid_let_reason = forbid_let_reason;
self.missing_let = missing_let;
self.comparison = comparison;
@ -3992,7 +3992,7 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
| ExprKind::Paren(_) => {
let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(OtherForbidden);
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
self.forbid_let_reason = forbid_let_reason;
}
ExprKind::Cast(ref mut op, _) | ExprKind::Type(ref mut op, _) => {

2
compiler/rustc_parse/src/parser/pat.rs
View File

@ -810,7 +810,7 @@ fn visit_pat(&mut self, pat: &mut P<Pat>) {
self.0 = true;
*m = Mutability::Mut;
}
walk_pat(pat, self);
walk_pat(self, pat);
}
}

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

19
tests/ui-fulldeps/pprust-expr-roundtrip.rs
View File

@ -46,9 +46,11 @@
fn parse_expr(psess: &ParseSess, src: &str) -> Option<P<Expr>> {
let src_as_string = src.to_string();
let mut p = unwrap_or_emit_fatal(
new_parser_from_source_str(psess, FileName::Custom(src_as_string.clone()), src_as_string)
);
let mut p = unwrap_or_emit_fatal(new_parser_from_source_str(
psess,
FileName::Custom(src_as_string.clone()),
src_as_string,
));
p.parse_expr().map_err(|e| e.cancel()).ok()
}
@ -181,10 +183,9 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
18 => {
let pat =
P(Pat { id: DUMMY_NODE_ID, kind: PatKind::Wild, span: DUMMY_SP, tokens: None });
iter_exprs(
depth - 1,
&mut |e| g(ExprKind::Let(pat.clone(), e, DUMMY_SP, Recovered::No))
)
iter_exprs(depth - 1, &mut |e| {
g(ExprKind::Let(pat.clone(), e, DUMMY_SP, Recovered::No))
})
}
_ => panic!("bad counter value in iter_exprs"),
}
@ -202,7 +203,7 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
ExprKind::Paren(inner) => *e = inner,
_ => {}
};
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
}
}
@ -211,7 +212,7 @@ fn visit_expr(&mut self, e: &mut P<Expr>) {
impl MutVisitor for AddParens {
fn visit_expr(&mut self, e: &mut P<Expr>) {
mut_visit::walk_expr(e, self);
mut_visit::walk_expr(self, e);
visit_clobber(e, |e| {
P(Expr {
id: DUMMY_NODE_ID,