bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Use let_else in even more places

Browse source
This commit is contained in:
est31 2022-01-18 20:26:13 +01:00
parent 9ad5d82f82
commit b2dd1377c7
9 changed files with 134 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View file

@ -1493,7 +1493,7 @@ fn generator_layout_and_saved_local_names<'tcx>(
let state_arg = mir::Local::new(1); let state_arg = mir::Local::new(1);
for var in &body.var_debug_info { for var in &body.var_debug_info {
let place = if let mir::VarDebugInfoContents::Place(p) = var.value { p } else { continue }; let mir::VarDebugInfoContents::Place(place) = &var.value else { continue };
if place.local != state_arg { if place.local != state_arg {
continue; continue;
} }

1
compiler/rustc_codegen_llvm/src/lib.rs
View file

@ -7,6 +7,7 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(bool_to_option)] #![feature(bool_to_option)]
#![feature(crate_visibility_modifier)] #![feature(crate_visibility_modifier)]
#![feature(let_else)]
#![feature(extern_types)] #![feature(extern_types)]
#![feature(nll)] #![feature(nll)]
#![recursion_limit = "256"] #![recursion_limit = "256"]

1
compiler/rustc_interface/src/lib.rs
View file

@ -1,5 +1,6 @@
#![feature(bool_to_option)] #![feature(bool_to_option)]
#![feature(box_patterns)] #![feature(box_patterns)]
#![feature(let_else)]
#![feature(internal_output_capture)] #![feature(internal_output_capture)]
#![feature(thread_spawn_unchecked)] #![feature(thread_spawn_unchecked)]
#![feature(nll)] #![feature(nll)]

94
compiler/rustc_interface/src/util.rs
View file

@ -717,57 +717,57 @@ impl<'a, 'b> ReplaceBodyWithLoop<'a, 'b> {
} }
fn should_ignore_fn(ret_ty: &ast::FnRetTy) -> bool { fn should_ignore_fn(ret_ty: &ast::FnRetTy) -> bool {
if let ast::FnRetTy::Ty(ref ty) = ret_ty { let ast::FnRetTy::Ty(ref ty) = ret_ty else {
fn involves_impl_trait(ty: &ast::Ty) -> bool { return false;
match ty.kind { };
ast::TyKind::ImplTrait(..) => true, fn involves_impl_trait(ty: &ast::Ty) -> bool {
ast::TyKind::Slice(ref subty) match ty.kind {
| ast::TyKind::Array(ref subty, _) ast::TyKind::ImplTrait(..) => true,
| ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) ast::TyKind::Slice(ref subty)
| ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) | ast::TyKind::Array(ref subty, _)
| ast::TyKind::Paren(ref subty) => involves_impl_trait(subty), | ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. })
ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()), | ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. })
ast::TyKind::Path(_, ref path) => { | ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
path.segments.iter().any(|seg| match seg.args.as_deref() { ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
None => false, ast::TyKind::Path(_, ref path) => {
Some(&ast::GenericArgs::AngleBracketed(ref data)) => { path.segments.iter().any(|seg| match seg.args.as_deref() {
data.args.iter().any(|arg| match arg { None => false,
ast::AngleBracketedArg::Arg(arg) => match arg { Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
ast::GenericArg::Type(ty) => involves_impl_trait(ty), data.args.iter().any(|arg| match arg {
ast::GenericArg::Lifetime(_) ast::AngleBracketedArg::Arg(arg) => match arg {
| ast::GenericArg::Const(_) => false, ast::GenericArg::Type(ty) => involves_impl_trait(ty),
}, ast::GenericArg::Lifetime(_) | ast::GenericArg::Const(_) => {
ast::AngleBracketedArg::Constraint(c) => match c.kind { false
ast::AssocConstraintKind::Bound { .. } => true, }
ast::AssocConstraintKind::Equality { ref term } => { },
match term { ast::AngleBracketedArg::Constraint(c) => match c.kind {
Term::Ty(ty) => involves_impl_trait(ty), ast::AssocConstraintKind::Bound { .. } => true,
// FIXME(...): This should check if the constant ast::AssocConstraintKind::Equality { ref term } => {
// involves a trait impl, but for now ignore. match term {
Term::Const(_) => false, Term::Ty(ty) => involves_impl_trait(ty),
} // FIXME(...): This should check if the constant
// involves a trait impl, but for now ignore.
Term::Const(_) => false,
} }
}, }
}) },
} })
Some(&ast::GenericArgs::Parenthesized(ref data)) => { }
any_involves_impl_trait(data.inputs.iter()) Some(&ast::GenericArgs::Parenthesized(ref data)) => {
|| ReplaceBodyWithLoop::should_ignore_fn(&data.output) any_involves_impl_trait(data.inputs.iter())
} || ReplaceBodyWithLoop::should_ignore_fn(&data.output)
}) }
} })
_ => false,
} }
_ => false,
} }
fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
it.any(|subty| involves_impl_trait(subty))
}
involves_impl_trait(ty)
} else {
false
} }
fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
it.any(|subty| involves_impl_trait(subty))
}
involves_impl_trait(ty)
} }
fn is_sig_const(sig: &ast::FnSig) -> bool { fn is_sig_const(sig: &ast::FnSig) -> bool {

31
compiler/rustc_mir_build/src/build/matches/mod.rs
View file

@ -1328,23 +1328,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
let mut otherwise = None; let mut otherwise = None;
for match_pair in match_pairs { for match_pair in match_pairs {
if let PatKind::Or { ref pats } = *match_pair.pattern.kind { let PatKind::Or { ref pats } = &*match_pair.pattern.kind else {
let or_span = match_pair.pattern.span;
let place = match_pair.place;
first_candidate.visit_leaves(|leaf_candidate| {
self.test_or_pattern(
leaf_candidate,
&mut otherwise,
pats,
or_span,
place.clone(),
fake_borrows,
);
});
} else {
bug!("Or-patterns should have been sorted to the end"); bug!("Or-patterns should have been sorted to the end");
} };
let or_span = match_pair.pattern.span;
let place = match_pair.place;
first_candidate.visit_leaves(|leaf_candidate| {
self.test_or_pattern(
leaf_candidate,
&mut otherwise,
pats,
or_span,
place.clone(),
fake_borrows,
);
});
} }
let remainder_start = otherwise.unwrap_or_else(|| self.cfg.start_new_block()); let remainder_start = otherwise.unwrap_or_else(|| self.cfg.start_new_block());

7
compiler/rustc_mir_build/src/build/matches/test.rs
View file

@ -88,11 +88,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
switch_ty: Ty<'tcx>, switch_ty: Ty<'tcx>,
options: &mut FxIndexMap<&'tcx ty::Const<'tcx>, u128>, options: &mut FxIndexMap<&'tcx ty::Const<'tcx>, u128>,
) -> bool { ) -> bool {
let match_pair = match candidate.match_pairs.iter().find(|mp| mp.place == *test_place) { let Some(match_pair) = candidate.match_pairs.iter().find(|mp| mp.place == *test_place) else {
Some(match_pair) => match_pair, return false;
_ => {
return false;
}
}; };
match *match_pair.pattern.kind { match *match_pair.pattern.kind {

4
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -1162,9 +1162,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
ident: Symbol, ident: Symbol,
kind: &AssocItemKind, kind: &AssocItemKind,
) -> Option<Symbol> { ) -> Option<Symbol> {
let module = if let Some((module, _)) = self.current_trait_ref { let Some((module, _)) = &self.current_trait_ref else {
module
} else {
return None; return None;
}; };
if ident == kw::Underscore { if ident == kw::Underscore {

73
compiler/rustc_resolve/src/late/lifetimes.rs
View file

@ -1000,46 +1000,45 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
// `fn foo<'a>() -> MyAnonTy<'a> { ... }` // `fn foo<'a>() -> MyAnonTy<'a> { ... }`
// ^ ^this gets resolved in the current scope // ^ ^this gets resolved in the current scope
for lifetime in lifetimes { for lifetime in lifetimes {
if let hir::GenericArg::Lifetime(lifetime) = lifetime { let hir::GenericArg::Lifetime(lifetime) = lifetime else {
self.visit_lifetime(lifetime); continue
};
self.visit_lifetime(lifetime);
// Check for predicates like `impl for<'a> Trait<impl OtherTrait<'a>>` // Check for predicates like `impl for<'a> Trait<impl OtherTrait<'a>>`
// and ban them. Type variables instantiated inside binders aren't // and ban them. Type variables instantiated inside binders aren't
// well-supported at the moment, so this doesn't work. // well-supported at the moment, so this doesn't work.
// In the future, this should be fixed and this error should be removed. // In the future, this should be fixed and this error should be removed.
let def = self.map.defs.get(&lifetime.hir_id).cloned(); let def = self.map.defs.get(&lifetime.hir_id).cloned();
if let Some(Region::LateBound(_, _, def_id, _)) = def { let Some(Region::LateBound(_, _, def_id, _)) = def else {
if let Some(def_id) = def_id.as_local() { continue
let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); };
// Ensure that the parent of the def is an item, not HRTB let Some(def_id) = def_id.as_local() else {
let parent_id = self.tcx.hir().get_parent_node(hir_id); continue
// FIXME(cjgillot) Can this check be replaced by };
// `let parent_is_item = parent_id.is_owner();`? let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id);
let parent_is_item = // Ensure that the parent of the def is an item, not HRTB
if let Some(parent_def_id) = parent_id.as_owner() { let parent_id = self.tcx.hir().get_parent_node(hir_id);
matches!( // FIXME(cjgillot) Can this check be replaced by
self.tcx.hir().krate().owners.get(parent_def_id), // `let parent_is_item = parent_id.is_owner();`?
Some(Some(_)), let parent_is_item = if let Some(parent_def_id) = parent_id.as_owner() {
) matches!(self.tcx.hir().krate().owners.get(parent_def_id), Some(Some(_)),)
} else { } else {
false false
}; };
if !parent_is_item { if !parent_is_item {
if !self.trait_definition_only { if !self.trait_definition_only {
struct_span_err!( struct_span_err!(
self.tcx.sess, self.tcx.sess,
lifetime.span, lifetime.span,
E0657, E0657,
"`impl Trait` can only capture lifetimes \ "`impl Trait` can only capture lifetimes \
bound at the fn or impl level" bound at the fn or impl level"
) )
.emit(); .emit();
}
self.uninsert_lifetime_on_error(lifetime, def.unwrap());
}
}
} }
self.uninsert_lifetime_on_error(lifetime, def.unwrap());
} }
} }

61
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -840,39 +840,38 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
}; };
for refs_remaining in 0..refs_number { for refs_remaining in 0..refs_number {
if let ty::Ref(_, inner_ty, _) = suggested_ty.kind() { let ty::Ref(_, inner_ty, _) = suggested_ty.kind() else {
suggested_ty = inner_ty; break;
};
suggested_ty = inner_ty;
let new_obligation = self.mk_trait_obligation_with_new_self_ty( let new_obligation = self.mk_trait_obligation_with_new_self_ty(
obligation.param_env, obligation.param_env,
trait_ref, trait_ref,
suggested_ty, suggested_ty,
);
if self.predicate_may_hold(&new_obligation) {
let sp = self
.tcx
.sess
.source_map()
.span_take_while(span, |c| c.is_whitespace() || *c == '&');
let remove_refs = refs_remaining + 1;
let msg = if remove_refs == 1 {
"consider removing the leading `&`-reference".to_string()
} else {
format!("consider removing {} leading `&`-references", remove_refs)
};
err.span_suggestion_short(
sp,
&msg,
String::new(),
Applicability::MachineApplicable,
); );
if self.predicate_may_hold(&new_obligation) {
let sp = self
.tcx
.sess
.source_map()
.span_take_while(span, |c| c.is_whitespace() || *c == '&');
let remove_refs = refs_remaining + 1;
let msg = if remove_refs == 1 {
"consider removing the leading `&`-reference".to_string()
} else {
format!("consider removing {} leading `&`-references", remove_refs)
};
err.span_suggestion_short(
sp,
&msg,
String::new(),
Applicability::MachineApplicable,
);
break;
}
} else {
break; break;
} }
} }