Skip to content

Commit 7d2d72f

Browse files
JarchoJarcho
committed
Use ControlFlow in AST visitors.
1 parent c7beecf commit 7d2d72f

File tree

5 files changed

+70
-67
lines changed

5 files changed

+70
-67
lines changed

‎compiler/rustc_ast_lowering/src/format.rs

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
use super::LoweringContext;
2+
use core::ops::ControlFlow;
23
use rustc_ast as ast;
34
use rustc_ast::visit::Visitor;
45
use rustc_ast::*;
@@ -594,30 +595,32 @@ fn expand_format_args<'hir>(
594595
}
595596

596597
fn may_contain_yield_point(e: &ast::Expr) -> bool {
597-
struct MayContainYieldPoint(bool);
598+
struct MayContainYieldPoint;
598599

599600
impl Visitor<'_> for MayContainYieldPoint {
600-
fn visit_expr(&mut self, e: &ast::Expr) {
601+
type Result = ControlFlow<()>;
602+
603+
fn visit_expr(&mut self, e: &ast::Expr) -> ControlFlow<()> {
601604
if let ast::ExprKind::Await(_, _) | ast::ExprKind::Yield(_) = e.kind {
602-
self.0 = true;
605+
ControlFlow::Break(())
603606
} else {
604607
visit::walk_expr(self, e);
608+
ControlFlow::Continue(())
605609
}
606610
}
607611

608-
fn visit_mac_call(&mut self, _: &ast::MacCall) {
612+
fn visit_mac_call(&mut self, _: &ast::MacCall) -> ControlFlow<()> {
609613
// Macros should be expanded at this point.
610614
unreachable!("unexpanded macro in ast lowering");
611615
}
612616

613-
fn visit_item(&mut self, _: &ast::Item) {
617+
fn visit_item(&mut self, _: &ast::Item) -> ControlFlow<()> {
614618
// Do not recurse into nested items.
619+
ControlFlow::Continue(())
615620
}
616621
}
617622

618-
let mut visitor = MayContainYieldPoint(false);
619-
visitor.visit_expr(e);
620-
visitor.0
623+
MayContainYieldPoint.visit_expr(e).is_break()
621624
}
622625

623626
fn for_all_argument_indexes(template: &mut [FormatArgsPiece], mut f: impl FnMut(&mut usize)) {

‎compiler/rustc_builtin_macros/src/cfg_eval.rs

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
22

3+
use core::ops::ControlFlow;
34
use rustc_ast as ast;
45
use rustc_ast::mut_visit::MutVisitor;
56
use rustc_ast::ptr::P;
@@ -87,41 +88,40 @@ fn flat_map_annotatable(
8788
}
8889
}
8990

90-
struct CfgFinder {
91-
has_cfg_or_cfg_attr: bool,
92-
}
93-
94-
impl CfgFinder {
95-
fn has_cfg_or_cfg_attr(annotatable: &Annotatable) -> bool {
96-
let mut finder = CfgFinder { has_cfg_or_cfg_attr: false };
97-
match annotatable {
98-
Annotatable::Item(item) => finder.visit_item(item),
99-
Annotatable::TraitItem(item) => finder.visit_assoc_item(item, visit::AssocCtxt::Trait),
100-
Annotatable::ImplItem(item) => finder.visit_assoc_item(item, visit::AssocCtxt::Impl),
101-
Annotatable::ForeignItem(item) => finder.visit_foreign_item(item),
102-
Annotatable::Stmt(stmt) => finder.visit_stmt(stmt),
103-
Annotatable::Expr(expr) => finder.visit_expr(expr),
104-
Annotatable::Arm(arm) => finder.visit_arm(arm),
105-
Annotatable::ExprField(field) => finder.visit_expr_field(field),
106-
Annotatable::PatField(field) => finder.visit_pat_field(field),
107-
Annotatable::GenericParam(param) => finder.visit_generic_param(param),
108-
Annotatable::Param(param) => finder.visit_param(param),
109-
Annotatable::FieldDef(field) => finder.visit_field_def(field),
110-
Annotatable::Variant(variant) => finder.visit_variant(variant),
111-
Annotatable::Crate(krate) => finder.visit_crate(krate),
112-
};
113-
finder.has_cfg_or_cfg_attr
114-
}
115-
}
91+
fn has_cfg_or_cfg_attr(annotatable: &Annotatable) -> bool {
92+
struct CfgFinder;
11693

117-
impl<'ast> visit::Visitor<'ast> for CfgFinder {
118-
fn visit_attribute(&mut self, attr: &'ast Attribute) {
119-
// We want short-circuiting behavior, so don't use the '|=' operator.
120-
self.has_cfg_or_cfg_attr = self.has_cfg_or_cfg_attr
121-
|| attr
94+
impl<'ast> visit::Visitor<'ast> for CfgFinder {
95+
type Result = ControlFlow<()>;
96+
fn visit_attribute(&mut self, attr: &'ast Attribute) -> ControlFlow<()> {
97+
if attr
12298
.ident()
123-
.is_some_and(|ident| ident.name == sym::cfg || ident.name == sym::cfg_attr);
99+
.is_some_and(|ident| ident.name == sym::cfg || ident.name == sym::cfg_attr)
100+
{
101+
ControlFlow::Break(())
102+
} else {
103+
ControlFlow::Continue(())
104+
}
105+
}
124106
}
107+
108+
let res = match annotatable {
109+
Annotatable::Item(item) => CfgFinder.visit_item(item),
110+
Annotatable::TraitItem(item) => CfgFinder.visit_assoc_item(item, visit::AssocCtxt::Trait),
111+
Annotatable::ImplItem(item) => CfgFinder.visit_assoc_item(item, visit::AssocCtxt::Impl),
112+
Annotatable::ForeignItem(item) => CfgFinder.visit_foreign_item(item),
113+
Annotatable::Stmt(stmt) => CfgFinder.visit_stmt(stmt),
114+
Annotatable::Expr(expr) => CfgFinder.visit_expr(expr),
115+
Annotatable::Arm(arm) => CfgFinder.visit_arm(arm),
116+
Annotatable::ExprField(field) => CfgFinder.visit_expr_field(field),
117+
Annotatable::PatField(field) => CfgFinder.visit_pat_field(field),
118+
Annotatable::GenericParam(param) => CfgFinder.visit_generic_param(param),
119+
Annotatable::Param(param) => CfgFinder.visit_param(param),
120+
Annotatable::FieldDef(field) => CfgFinder.visit_field_def(field),
121+
Annotatable::Variant(variant) => CfgFinder.visit_variant(variant),
122+
Annotatable::Crate(krate) => CfgFinder.visit_crate(krate),
123+
};
124+
res.is_break()
125125
}
126126

127127
impl CfgEval<'_, '_> {
@@ -132,7 +132,7 @@ impl CfgEval<'_, '_> {
132132
fn configure_annotatable(&mut self, mut annotatable: Annotatable) -> Option<Annotatable> {
133133
// Tokenizing and re-parsing the `Annotatable` can have a significant
134134
// performance impact, so try to avoid it if possible
135-
if !CfgFinder::has_cfg_or_cfg_attr(&annotatable) {
135+
if !has_cfg_or_cfg_attr(&annotatable) {
136136
return Some(annotatable);
137137
}
138138

‎compiler/rustc_builtin_macros/src/deriving/default.rs

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use crate::deriving::generic::ty::*;
22
use crate::deriving::generic::*;
33
use crate::errors;
4+
use core::ops::ControlFlow;
45
use rustc_ast as ast;
56
use rustc_ast::{attr, walk_list, EnumDef, VariantData};
67
use rustc_expand::base::{Annotatable, DummyResult, ExtCtxt};
@@ -230,20 +231,19 @@ impl<'a, 'b> rustc_ast::visit::Visitor<'a> for DetectNonVariantDefaultAttr<'a, '
230231
}
231232

232233
fn has_a_default_variant(item: &Annotatable) -> bool {
233-
struct HasDefaultAttrOnVariant {
234-
found: bool,
235-
}
234+
struct HasDefaultAttrOnVariant;
236235

237236
impl<'ast> rustc_ast::visit::Visitor<'ast> for HasDefaultAttrOnVariant {
238-
fn visit_variant(&mut self, v: &'ast rustc_ast::Variant) {
237+
type Result = ControlFlow<()>;
238+
fn visit_variant(&mut self, v: &'ast rustc_ast::Variant) -> ControlFlow<()> {
239239
if v.attrs.iter().any(|attr| attr.has_name(kw::Default)) {
240-
self.found = true;
240+
ControlFlow::Break(())
241+
} else {
242+
// no need to subrecurse.
243+
ControlFlow::Continue(())
241244
}
242-
// no need to subrecurse.
243245
}
244246
}
245247

246-
let mut visitor = HasDefaultAttrOnVariant { found: false };
247-
item.visit_with(&mut visitor);
248-
visitor.found
248+
item.visit_with(&mut HasDefaultAttrOnVariant).is_break()
249249
}

‎compiler/rustc_lint/src/unused.rs

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ use rustc_span::symbol::Symbol;
2020
use rustc_span::symbol::{kw, sym};
2121
use rustc_span::{BytePos, Span};
2222
use std::iter;
23+
use std::ops::ControlFlow;
2324

2425
declare_lint! {
2526
/// The `unused_must_use` lint detects unused result of a type flagged as
@@ -753,21 +754,18 @@ trait UnusedDelimLint {
753754
// fn f(){(print!(á
754755
// ```
755756
use rustc_ast::visit::{walk_expr, Visitor};
756-
struct ErrExprVisitor {
757-
has_error: bool,
758-
}
757+
struct ErrExprVisitor;
759758
impl<'ast> Visitor<'ast> for ErrExprVisitor {
760-
fn visit_expr(&mut self, expr: &'ast ast::Expr) {
759+
type Result = ControlFlow<()>;
760+
fn visit_expr(&mut self, expr: &'ast ast::Expr) -> ControlFlow<()> {
761761
if let ExprKind::Err(_) = expr.kind {
762-
self.has_error = true;
763-
return;
762+
ControlFlow::Break(())
763+
} else {
764+
walk_expr(self, expr)
764765
}
765-
walk_expr(self, expr)
766766
}
767767
}
768-
let mut visitor = ErrExprVisitor { has_error: false };
769-
visitor.visit_expr(value);
770-
if visitor.has_error {
768+
if ErrExprVisitor.visit_expr(value).is_break() {
771769
return;
772770
}
773771
let spans = match value.kind {

‎compiler/rustc_parse/src/parser/expr.rs

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13,13 +13,14 @@ use ast::mut_visit::{noop_visit_expr, MutVisitor};
1313
use ast::token::IdentIsRaw;
1414
use ast::{CoroutineKind, ForLoopKind, GenBlockKind, Pat, Path, PathSegment};
1515
use core::mem;
16+
use core::ops::ControlFlow;
1617
use rustc_ast::ptr::P;
1718
use rustc_ast::token::{self, Delimiter, Token, TokenKind};
1819
use rustc_ast::tokenstream::Spacing;
1920
use rustc_ast::util::case::Case;
2021
use rustc_ast::util::classify;
2122
use rustc_ast::util::parser::{prec_let_scrutinee_needs_par, AssocOp, Fixity};
22-
use rustc_ast::visit::Visitor;
23+
use rustc_ast::visit::{walk_expr, Visitor};
2324
use rustc_ast::{self as ast, AttrStyle, AttrVec, CaptureBy, ExprField, UnOp, DUMMY_NODE_ID};
2425
use rustc_ast::{AnonConst, BinOp, BinOpKind, FnDecl, FnRetTy, MacCall, Param, Ty, TyKind};
2526
use rustc_ast::{Arm, BlockCheckMode, Expr, ExprKind, Label, Movability, RangeLimits};
@@ -1703,19 +1704,20 @@ impl<'a> Parser<'a> {
17031704
let span = expr.span;
17041705

17051706
let found_labeled_breaks = {
1706-
struct FindLabeledBreaksVisitor(bool);
1707+
struct FindLabeledBreaksVisitor;
17071708

17081709
impl<'ast> Visitor<'ast> for FindLabeledBreaksVisitor {
1709-
fn visit_expr_post(&mut self, ex: &'ast Expr) {
1710+
type Result = ControlFlow<()>;
1711+
fn visit_expr(&mut self, ex: &'ast Expr) -> ControlFlow<()> {
17101712
if let ExprKind::Break(Some(_label), _) = ex.kind {
1711-
self.0 = true;
1713+
ControlFlow::Break(())
1714+
} else {
1715+
walk_expr(self, ex)
17121716
}
17131717
}
17141718
}
17151719

1716-
let mut vis = FindLabeledBreaksVisitor(false);
1717-
vis.visit_expr(&expr);
1718-
vis.0
1720+
FindLabeledBreaksVisitor.visit_expr(&expr).is_break()
17191721
};
17201722

17211723
// Suggestion involves adding a labeled block.

0 commit comments

Comments
 (0)