Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 5be38d2

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#94445 - c410-f3r:more-let-chains, r=cjgillot
4 - Make more use of `let_chains` Continuation of rust-lang#94376. cc rust-lang#53667
2 parents 975a0e0 + e3e902b commit 5be38d2

File tree

7 files changed

+72
-76
lines changed

7 files changed

+72
-76
lines changed

‎compiler/rustc_parse/src/lexer/tokentrees.rs‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -282,14 +282,13 @@ struct TokenStreamBuilder {
282282

283283
impl TokenStreamBuilder {
284284
fn push(&mut self, (tree, joint): TreeAndSpacing) {
285-
if let Some((TokenTree::Token(prev_token), Joint)) = self.buf.last() {
286-
if let TokenTree::Token(token) = &tree {
287-
if let Some(glued) = prev_token.glue(token) {
288-
self.buf.pop();
289-
self.buf.push((TokenTree::Token(glued), joint));
290-
return;
291-
}
292-
}
285+
if let Some((TokenTree::Token(prev_token), Joint)) = self.buf.last()
286+
&& let TokenTree::Token(token) = &tree
287+
&& let Some(glued) = prev_token.glue(token)
288+
{
289+
self.buf.pop();
290+
self.buf.push((TokenTree::Token(glued), joint));
291+
return;
293292
}
294293
self.buf.push((tree, joint))
295294
}

‎compiler/rustc_parse/src/lib.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
11
//! The main parser interface.
22
33
#![feature(array_windows)]
4+
#![feature(box_patterns)]
45
#![feature(crate_visibility_modifier)]
56
#![feature(if_let_guard)]
6-
#![feature(box_patterns)]
7+
#![feature(let_chains)]
78
#![feature(let_else)]
89
#![recursion_limit = "256"]
910

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

Lines changed: 39 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -732,43 +732,42 @@ impl<'a> Parser<'a> {
732732
mut e: DiagnosticBuilder<'a, ErrorReported>,
733733
expr: &mut P<Expr>,
734734
) -> PResult<'a, ()> {
735-
if let ExprKind::Binary(binop, _, _) = &expr.kind {
736-
if let ast::BinOpKind::Lt = binop.node {
737-
if self.eat(&token::Comma) {
738-
let x = self.parse_seq_to_before_end(
739-
&token::Gt,
740-
SeqSep::trailing_allowed(token::Comma),
741-
|p| p.parse_generic_arg(None),
742-
);
743-
match x {
744-
Ok((_, _, false)) => {
745-
if self.eat(&token::Gt) {
746-
e.span_suggestion_verbose(
747-
binop.span.shrink_to_lo(),
748-
TURBOFISH_SUGGESTION_STR,
749-
"::".to_string(),
750-
Applicability::MaybeIncorrect,
751-
)
752-
.emit();
753-
match self.parse_expr() {
754-
Ok(_) => {
755-
*expr =
756-
self.mk_expr_err(expr.span.to(self.prev_token.span));
757-
return Ok(());
758-
}
759-
Err(err) => {
760-
*expr = self.mk_expr_err(expr.span);
761-
err.cancel();
762-
}
763-
}
735+
if let ExprKind::Binary(binop, _, _) = &expr.kind
736+
&& let ast::BinOpKind::Lt = binop.node
737+
&& self.eat(&token::Comma)
738+
{
739+
let x = self.parse_seq_to_before_end(
740+
&token::Gt,
741+
SeqSep::trailing_allowed(token::Comma),
742+
|p| p.parse_generic_arg(None),
743+
);
744+
match x {
745+
Ok((_, _, false)) => {
746+
if self.eat(&token::Gt) {
747+
e.span_suggestion_verbose(
748+
binop.span.shrink_to_lo(),
749+
TURBOFISH_SUGGESTION_STR,
750+
"::".to_string(),
751+
Applicability::MaybeIncorrect,
752+
)
753+
.emit();
754+
match self.parse_expr() {
755+
Ok(_) => {
756+
*expr =
757+
self.mk_expr_err(expr.span.to(self.prev_token.span));
758+
return Ok(());
759+
}
760+
Err(err) => {
761+
*expr = self.mk_expr_err(expr.span);
762+
err.cancel();
764763
}
765764
}
766-
Err(err) => {
767-
err.cancel();
768-
}
769-
_ => {}
770765
}
771766
}
767+
Err(err) => {
768+
err.cancel();
769+
}
770+
_ => {}
772771
}
773772
}
774773
Err(e)
@@ -784,12 +783,13 @@ impl<'a> Parser<'a> {
784783
outer_op: &Spanned<AssocOp>,
785784
) -> bool /* advanced the cursor */ {
786785
if let ExprKind::Binary(op, ref l1, ref r1) = inner_op.kind {
787-
if let ExprKind::Field(_, ident) = l1.kind {
788-
if ident.as_str().parse::<i32>().is_err() && !matches!(r1.kind, ExprKind::Lit(_)) {
789-
// The parser has encountered `foo.bar<baz`, the likelihood of the turbofish
790-
// suggestion being the only one to apply is high.
791-
return false;
792-
}
786+
if let ExprKind::Field(_, ident) = l1.kind
787+
&& ident.as_str().parse::<i32>().is_err()
788+
&& !matches!(r1.kind, ExprKind::Lit(_))
789+
{
790+
// The parser has encountered `foo.bar<baz`, the likelihood of the turbofish
791+
// suggestion being the only one to apply is high.
792+
return false;
793793
}
794794
let mut enclose = |left: Span, right: Span| {
795795
err.multipart_suggestion(

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

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -102,14 +102,12 @@ impl<'a> Parser<'a> {
102102
) -> PResult<'a, Option<Item>> {
103103
// Don't use `maybe_whole` so that we have precise control
104104
// over when we bump the parser
105-
if let token::Interpolated(nt) = &self.token.kind {
106-
if let token::NtItem(item) = &**nt {
107-
let mut item = item.clone();
108-
self.bump();
105+
if let token::Interpolated(nt) = &self.token.kind && let token::NtItem(item) = &**nt {
106+
let mut item = item.clone();
107+
self.bump();
109108

110-
attrs.prepend_to_nt_inner(&mut item.attrs);
111-
return Ok(Some(item.into_inner()));
112-
}
109+
attrs.prepend_to_nt_inner(&mut item.attrs);
110+
return Ok(Some(item.into_inner()));
113111
};
114112

115113
let mut unclosed_delims = vec![];

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -97,15 +97,15 @@ macro_rules! maybe_whole {
9797
#[macro_export]
9898
macro_rules! maybe_recover_from_interpolated_ty_qpath {
9999
($self: expr, $allow_qpath_recovery: expr) => {
100-
if $allow_qpath_recovery && $self.look_ahead(1, |t| t == &token::ModSep) {
101-
if let token::Interpolated(nt) = &$self.token.kind {
102-
if let token::NtTy(ty) = &**nt {
100+
if $allow_qpath_recovery
101+
&& $self.look_ahead(1, |t| t == &token::ModSep)
102+
&& let token::Interpolated(nt) = &$self.token.kind
103+
&& let token::NtTy(ty) = &**nt
104+
{
103105
let ty = ty.clone();
104106
$self.bump();
105107
return $self.maybe_recover_from_bad_qpath_stage_2($self.prev_token.span, ty);
106108
}
107-
}
108-
}
109109
};
110110
}
111111

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

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -658,13 +658,13 @@ impl<'a> Parser<'a> {
658658
&self,
659659
gen_arg: GenericArg,
660660
) -> Result<(Ident, Option<GenericArgs>), GenericArg> {
661-
if let GenericArg::Type(ty) = &gen_arg {
662-
if let ast::TyKind::Path(qself, path) = &ty.kind {
663-
if qself.is_none() && path.segments.len() == 1 {
664-
let seg = &path.segments[0];
665-
return Ok((seg.ident, seg.args.as_deref().cloned()));
666-
}
667-
}
661+
if let GenericArg::Type(ty) = &gen_arg
662+
&& let ast::TyKind::Path(qself, path) = &ty.kind
663+
&& qself.is_none()
664+
&& path.segments.len() == 1
665+
{
666+
let seg = &path.segments[0];
667+
return Ok((seg.ident, seg.args.as_deref().cloned()));
668668
}
669669
Err(gen_arg)
670670
}

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

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -48,15 +48,13 @@ impl<'a> Parser<'a> {
4848

4949
// Don't use `maybe_whole` so that we have precise control
5050
// over when we bump the parser
51-
if let token::Interpolated(nt) = &self.token.kind {
52-
if let token::NtStmt(stmt) = &**nt {
53-
let mut stmt = stmt.clone();
54-
self.bump();
55-
stmt.visit_attrs(|stmt_attrs| {
56-
attrs.prepend_to_nt_inner(stmt_attrs);
57-
});
58-
return Ok(Some(stmt));
59-
}
51+
if let token::Interpolated(nt) = &self.token.kind && let token::NtStmt(stmt) = &**nt {
52+
let mut stmt = stmt.clone();
53+
self.bump();
54+
stmt.visit_attrs(|stmt_attrs| {
55+
attrs.prepend_to_nt_inner(stmt_attrs);
56+
});
57+
return Ok(Some(stmt));
6058
}
6159

6260
Ok(Some(if self.token.is_keyword(kw::Let) {

0 commit comments

Comments
 (0)