From ca2ad69143eff606f051aed98422d98a8d4e43d8 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 26 Feb 2022 07:43:47 -0300
Subject: [PATCH] Make more use of `let_chains`
---
compiler/rustc_typeck/src/astconv/mod.rs | 11 ++-
compiler/rustc_typeck/src/check/check.rs | 39 ++++-----
compiler/rustc_typeck/src/check/coercion.rs | 11 ++-
compiler/rustc_typeck/src/check/demand.rs | 19 ++---
compiler/rustc_typeck/src/check/expr.rs | 6 +-
.../rustc_typeck/src/check/fn_ctxt/checks.rs | 30 ++++---
.../rustc_typeck/src/check/method/suggest.rs | 82 +++++++++----------
compiler/rustc_typeck/src/check/pat.rs | 9 +-
compiler/rustc_typeck/src/collect.rs | 65 +++++++--------
compiler/rustc_typeck/src/lib.rs | 13 +--
.../src/outlives/implicit_infer.rs | 13 ++-
11 files changed, 138 insertions(+), 160 deletions(-)
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index 4a310e2be3e..14a6e686a64 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -1054,12 +1054,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let mut result = Vec::new();
for ast_bound in ast_bounds {
- if let Some(trait_ref) = ast_bound.trait_ref() {
- if let Some(trait_did) = trait_ref.trait_def_id() {
- if self.tcx().trait_may_define_assoc_type(trait_did, assoc_name) {
- result.push(ast_bound.clone());
- }
- }
+ if let Some(trait_ref) = ast_bound.trait_ref()
+ && let Some(trait_did) = trait_ref.trait_def_id()
+ && self.tcx().trait_may_define_assoc_type(trait_did, assoc_name)
+ {
+ result.push(ast_bound.clone());
}
}
diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs
index 8ed87497f1b..100d2d07a5c 100644
--- a/compiler/rustc_typeck/src/check/check.rs
+++ b/compiler/rustc_typeck/src/check/check.rs
@@ -282,13 +282,12 @@ pub(super) fn check_fn<'a, 'tcx>(
sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
}
- if let Node::Item(item) = hir.get(fn_id) {
- if let ItemKind::Fn(_, ref generics, _) = item.kind {
- if !generics.params.is_empty() {
+ if let Node::Item(item) = hir.get(fn_id)
+ && let ItemKind::Fn(_, ref generics, _) = item.kind
+ && !generics.params.is_empty()
+ {
sess.span_err(span, "should have no type parameters");
}
- }
- }
} else {
let span = sess.source_map().guess_head_span(span);
sess.span_err(span, "function should have one argument");
@@ -319,17 +318,15 @@ pub(super) fn check_fn<'a, 'tcx>(
sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
}
- if let Node::Item(item) = hir.get(fn_id) {
- if let ItemKind::Fn(_, ref generics, _) = item.kind {
- if !generics.params.is_empty() {
+ if let Node::Item(item) = hir.get(fn_id)
+ && let ItemKind::Fn(_, ref generics, _) = item.kind
+ && !generics.params.is_empty()
+ {
sess.span_err(
span,
- "`#[alloc_error_handler]` function should have no type \
- parameters",
+ "`#[alloc_error_handler]` function should have no type parameters",
);
}
- }
- }
} else {
let span = sess.source_map().guess_head_span(span);
sess.span_err(span, "function should have one argument");
@@ -1146,9 +1143,10 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: &ty::AdtDef) {
if repr.packed() {
for attr in tcx.get_attrs(def.did).iter() {
for r in attr::find_repr_attrs(&tcx.sess, attr) {
- if let attr::ReprPacked(pack) = r {
- if let Some(repr_pack) = repr.pack {
- if pack as u64 != repr_pack.bytes() {
+ if let attr::ReprPacked(pack) = r
+ && let Some(repr_pack) = repr.pack
+ && pack as u64 != repr_pack.bytes()
+ {
struct_span_err!(
tcx.sess,
sp,
@@ -1156,8 +1154,6 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: &ty::AdtDef) {
"type has conflicting packed representation hints"
)
.emit();
- }
- }
}
}
}
@@ -1399,12 +1395,11 @@ fn display_discriminant_value<'tcx>(
) -> String {
if let Some(expr) = &variant.disr_expr {
let body = &tcx.hir().body(expr.body).value;
- if let hir::ExprKind::Lit(lit) = &body.kind {
- if let rustc_ast::LitKind::Int(lit_value, _int_kind) = &lit.node {
- if evaluated != *lit_value {
+ if let hir::ExprKind::Lit(lit) = &body.kind
+ && let rustc_ast::LitKind::Int(lit_value, _int_kind) = &lit.node
+ && evaluated != *lit_value
+ {
return format!("`{}` (overflowed from `{}`)", evaluated, lit_value);
- }
- }
}
}
format!("`{}`", evaluated)
diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs
index 8ca27b010b6..c6b14d3e104 100644
--- a/compiler/rustc_typeck/src/check/coercion.rs
+++ b/compiler/rustc_typeck/src/check/coercion.rs
@@ -1696,13 +1696,12 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
}
fn is_return_ty_unsized<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, blk_id: hir::HirId) -> bool {
- if let Some((fn_decl, _)) = fcx.get_fn_decl(blk_id) {
- if let hir::FnRetTy::Return(ty) = fn_decl.output {
- let ty = <dyn AstConv<'_>>::ast_ty_to_ty(fcx, ty);
- if let ty::Dynamic(..) = ty.kind() {
+ if let Some((fn_decl, _)) = fcx.get_fn_decl(blk_id)
+ && let hir::FnRetTy::Return(ty) = fn_decl.output
+ && let ty = <dyn AstConv<'_>>::ast_ty_to_ty(fcx, ty)
+ && let ty::Dynamic(..) = ty.kind()
+ {
return true;
- }
- }
}
false
}
diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs
index 80096b90f95..faead1bf5cd 100644
--- a/compiler/rustc_typeck/src/check/demand.rs
+++ b/compiler/rustc_typeck/src/check/demand.rs
@@ -587,9 +587,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match (&expr.kind, expected.kind(), checked_ty.kind()) {
(_, &ty::Ref(_, exp, _), &ty::Ref(_, check, _)) => match (exp.kind(), check.kind()) {
(&ty::Str, &ty::Array(arr, _) | &ty::Slice(arr)) if arr == self.tcx.types.u8 => {
- if let hir::ExprKind::Lit(_) = expr.kind {
- if let Ok(src) = sm.span_to_snippet(sp) {
- if replace_prefix(&src, "b\"", "\"").is_some() {
+ if let hir::ExprKind::Lit(_) = expr.kind
+ && let Ok(src) = sm.span_to_snippet(sp)
+ && replace_prefix(&src, "b\"", "\"").is_some()
+ {
let pos = sp.lo() + BytePos(1);
return Some((
sp.with_hi(pos),
@@ -600,12 +601,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
));
}
}
- }
- }
(&ty::Array(arr, _) | &ty::Slice(arr), &ty::Str) if arr == self.tcx.types.u8 => {
- if let hir::ExprKind::Lit(_) = expr.kind {
- if let Ok(src) = sm.span_to_snippet(sp) {
- if replace_prefix(&src, "\"", "b\"").is_some() {
+ if let hir::ExprKind::Lit(_) = expr.kind
+ && let Ok(src) = sm.span_to_snippet(sp)
+ && replace_prefix(&src, "\"", "b\"").is_some()
+ {
return Some((
sp.shrink_to_lo(),
"consider adding a leading `b`",
@@ -613,8 +613,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Applicability::MachineApplicable,
true,
));
- }
- }
+
}
}
_ => {}
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
index 8d4ffefda73..14a1318517a 100644
--- a/compiler/rustc_typeck/src/check/expr.rs
+++ b/compiler/rustc_typeck/src/check/expr.rs
@@ -810,10 +810,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Use the span of the trailing expression for our cause,
// not the span of the entire function
if !explicit_return {
- if let ExprKind::Block(body, _) = return_expr.kind {
- if let Some(last_expr) = body.expr {
- span = last_expr.span;
- }
+ if let ExprKind::Block(body, _) = return_expr.kind && let Some(last_expr) = body.expr {
+ span = last_expr.span;
}
}
ret_coercion.borrow_mut().coerce(
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
index 4b6460b62b7..76339998a2f 100644
--- a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
+++ b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
@@ -402,25 +402,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
);
}
- if let Some(def_id) = fn_def_id {
- if let Some(def_span) = tcx.def_ident_span(def_id) {
- let mut spans: MultiSpan = def_span.into();
+ if let Some(def_id) = fn_def_id && let Some(def_span) = tcx.def_ident_span(def_id) {
+ let mut spans: MultiSpan = def_span.into();
- let params = tcx
- .hir()
- .get_if_local(def_id)
- .and_then(|node| node.body_id())
- .into_iter()
- .map(|id| tcx.hir().body(id).params)
- .flatten();
+ let params = tcx
+ .hir()
+ .get_if_local(def_id)
+ .and_then(|node| node.body_id())
+ .into_iter()
+ .map(|id| tcx.hir().body(id).params)
+ .flatten();
- for param in params {
- spans.push_span_label(param.span, String::new());
- }
-
- let def_kind = tcx.def_kind(def_id);
- err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
+ for param in params {
+ spans.push_span_label(param.span, String::new());
}
+
+ let def_kind = tcx.def_kind(def_id);
+ err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
}
if sugg_unit {
let sugg_span = tcx.sess.source_map().end_point(call_expr.span);
diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs
index ccaea10233d..32de5d23c1e 100644
--- a/compiler/rustc_typeck/src/check/method/suggest.rs
+++ b/compiler/rustc_typeck/src/check/method/suggest.rs
@@ -430,12 +430,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
actual.prefix_string(self.tcx),
ty_str_reported,
);
- if let Mode::MethodCall = mode {
- if let SelfSource::MethodCall(call) = source {
- self.suggest_await_before_method(
- &mut err, item_name, actual, call, span,
- );
- }
+ if let Mode::MethodCall = mode && let SelfSource::MethodCall(cal) = source {
+ self.suggest_await_before_method(
+ &mut err, item_name, actual, cal, span,
+ );
}
if let Some(span) =
tcx.resolutions(()).confused_type_with_std_module.get(&span)
@@ -1525,43 +1523,41 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
(self.tcx.mk_diagnostic_item(*rcvr_ty, sym::Arc), "Arc::new"),
(self.tcx.mk_diagnostic_item(*rcvr_ty, sym::Rc), "Rc::new"),
] {
- if let Some(new_rcvr_t) = *rcvr_ty {
- if let Ok(pick) = self.lookup_probe(
- span,
- item_name,
- new_rcvr_t,
- rcvr,
- crate::check::method::probe::ProbeScope::AllTraits,
- ) {
- debug!("try_alt_rcvr: pick candidate {:?}", pick);
- let did = Some(pick.item.container.id());
- // We don't want to suggest a container type when the missing
- // method is `.clone()` or `.deref()` otherwise we'd suggest
- // `Arc::new(foo).clone()`, which is far from what the user wants.
- // Explicitly ignore the `Pin::as_ref()` method as `Pin` does not
- // implement the `AsRef` trait.
- let skip = skippable.contains(&did)
- || (("Pin::new" == *pre) && (sym::as_ref == item_name.name));
- // Make sure the method is defined for the *actual* receiver: we don't
- // want to treat `Box<Self>` as a receiver if it only works because of
- // an autoderef to `&self`
- if pick.autoderefs == 0 && !skip {
- err.span_label(
- pick.item.ident(self.tcx).span,
- &format!("the method is available for `{}` here", new_rcvr_t),
- );
- err.multipart_suggestion(
- "consider wrapping the receiver expression with the \
- appropriate type",
- vec![
- (rcvr.span.shrink_to_lo(), format!("{}({}", pre, post)),
- (rcvr.span.shrink_to_hi(), ")".to_string()),
- ],
- Applicability::MaybeIncorrect,
- );
- // We don't care about the other suggestions.
- alt_rcvr_sugg = true;
- }
+ if let Some(new_rcvr_t) = *rcvr_ty && let Ok(pick) = self.lookup_probe(
+ span,
+ item_name,
+ new_rcvr_t,
+ rcvr,
+ crate::check::method::probe::ProbeScope::AllTraits,
+ ) {
+ debug!("try_alt_rcvr: pick candidate {:?}", pick);
+ let did = Some(pick.item.container.id());
+ // We don't want to suggest a container type when the missing
+ // method is `.clone()` or `.deref()` otherwise we'd suggest
+ // `Arc::new(foo).clone()`, which is far from what the user wants.
+ // Explicitly ignore the `Pin::as_ref()` method as `Pin` does not
+ // implement the `AsRef` trait.
+ let skip = skippable.contains(&did)
+ || (("Pin::new" == *pre) && (sym::as_ref == item_name.name));
+ // Make sure the method is defined for the *actual* receiver: we don't
+ // want to treat `Box<Self>` as a receiver if it only works because of
+ // an autoderef to `&self`
+ if pick.autoderefs == 0 && !skip {
+ err.span_label(
+ pick.item.ident(self.tcx).span,
+ &format!("the method is available for `{}` here", new_rcvr_t),
+ );
+ err.multipart_suggestion(
+ "consider wrapping the receiver expression with the \
+ appropriate type",
+ vec![
+ (rcvr.span.shrink_to_lo(), format!("{}({}", pre, post)),
+ (rcvr.span.shrink_to_hi(), ")".to_string()),
+ ],
+ Applicability::MaybeIncorrect,
+ );
+ // We don't care about the other suggestions.
+ alt_rcvr_sugg = true;
}
}
}
diff --git a/compiler/rustc_typeck/src/check/pat.rs b/compiler/rustc_typeck/src/check/pat.rs
index 7c6917734b2..9963a922268 100644
--- a/compiler/rustc_typeck/src/check/pat.rs
+++ b/compiler/rustc_typeck/src/check/pat.rs
@@ -685,9 +685,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
pub fn check_dereferenceable(&self, span: Span, expected: Ty<'tcx>, inner: &Pat<'_>) -> bool {
- if let PatKind::Binding(..) = inner.kind {
- if let Some(mt) = self.shallow_resolve(expected).builtin_deref(true) {
- if let ty::Dynamic(..) = mt.ty.kind() {
+ if let PatKind::Binding(..) = inner.kind
+ && let Some(mt) = self.shallow_resolve(expected).builtin_deref(true)
+ && let ty::Dynamic(..) = mt.ty.kind()
+ {
// This is "x = SomeTrait" being reduced from
// "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
let type_str = self.ty_to_string(expected);
@@ -705,8 +706,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
err.emit();
return false;
}
- }
- }
true
}
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
index 2317ae43f11..88e3e67c99e 100644
--- a/compiler/rustc_typeck/src/collect.rs
+++ b/compiler/rustc_typeck/src/collect.rs
@@ -190,25 +190,23 @@ crate fn placeholder_type_error<'tcx>(
let mut is_fn = false;
let mut is_const_or_static = false;
- if let Some(hir_ty) = hir_ty {
- if let hir::TyKind::BareFn(_) = hir_ty.kind {
- is_fn = true;
+ if let Some(hir_ty) = hir_ty && let hir::TyKind::BareFn(_) = hir_ty.kind {
+ is_fn = true;
- // Check if parent is const or static
- let parent_id = tcx.hir().get_parent_node(hir_ty.hir_id);
- let parent_node = tcx.hir().get(parent_id);
+ // Check if parent is const or static
+ let parent_id = tcx.hir().get_parent_node(hir_ty.hir_id);
+ let parent_node = tcx.hir().get(parent_id);
- is_const_or_static = matches!(
- parent_node,
- Node::Item(&hir::Item {
- kind: hir::ItemKind::Const(..) | hir::ItemKind::Static(..),
- ..
- }) | Node::TraitItem(&hir::TraitItem {
- kind: hir::TraitItemKind::Const(..),
- ..
- }) | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Const(..), .. })
- );
- }
+ is_const_or_static = matches!(
+ parent_node,
+ Node::Item(&hir::Item {
+ kind: hir::ItemKind::Const(..) | hir::ItemKind::Static(..),
+ ..
+ }) | Node::TraitItem(&hir::TraitItem {
+ kind: hir::TraitItemKind::Const(..),
+ ..
+ }) | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Const(..), .. })
+ );
}
// if function is wrapped around a const or static,
@@ -2417,16 +2415,14 @@ fn const_evaluatable_predicates_of<'tcx>(
let node = tcx.hir().get(hir_id);
let mut collector = ConstCollector { tcx, preds: FxIndexSet::default() };
- if let hir::Node::Item(item) = node {
- if let hir::ItemKind::Impl(ref impl_) = item.kind {
- if let Some(of_trait) = &impl_.of_trait {
- debug!("const_evaluatable_predicates_of({:?}): visit impl trait_ref", def_id);
- collector.visit_trait_ref(of_trait);
- }
-
- debug!("const_evaluatable_predicates_of({:?}): visit_self_ty", def_id);
- collector.visit_ty(impl_.self_ty);
+ if let hir::Node::Item(item) = node && let hir::ItemKind::Impl(ref impl_) = item.kind {
+ if let Some(of_trait) = &impl_.of_trait {
+ debug!("const_evaluatable_predicates_of({:?}): visit impl trait_ref", def_id);
+ collector.visit_trait_ref(of_trait);
}
+
+ debug!("const_evaluatable_predicates_of({:?}): visit_self_ty", def_id);
+ collector.visit_ty(impl_.self_ty);
}
if let Some(generics) = node.generics() {
@@ -3280,15 +3276,14 @@ fn asm_target_features<'tcx>(tcx: TyCtxt<'tcx>, id: DefId) -> &'tcx FxHashSet<Sy
/// Checks if the provided DefId is a method in a trait impl for a trait which has track_caller
/// applied to the method prototype.
fn should_inherit_track_caller(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
- if let Some(impl_item) = tcx.opt_associated_item(def_id) {
- if let ty::AssocItemContainer::ImplContainer(_) = impl_item.container {
- if let Some(trait_item) = impl_item.trait_item_def_id {
- return tcx
- .codegen_fn_attrs(trait_item)
- .flags
- .intersects(CodegenFnAttrFlags::TRACK_CALLER);
- }
- }
+ if let Some(impl_item) = tcx.opt_associated_item(def_id)
+ && let ty::AssocItemContainer::ImplContainer(_) = impl_item.container
+ && let Some(trait_item) = impl_item.trait_item_def_id
+ {
+ return tcx
+ .codegen_fn_attrs(trait_item)
+ .flags
+ .intersects(CodegenFnAttrFlags::TRACK_CALLER);
}
false
diff --git a/compiler/rustc_typeck/src/lib.rs b/compiler/rustc_typeck/src/lib.rs
index f0289fd505a..de030c5b60b 100644
--- a/compiler/rustc_typeck/src/lib.rs
+++ b/compiler/rustc_typeck/src/lib.rs
@@ -55,22 +55,23 @@ This API is completely unstable and subject to change.
*/
+#![allow(rustc::potential_query_instability)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(bool_to_option)]
+#![feature(control_flow_enum)]
#![feature(crate_visibility_modifier)]
+#![feature(hash_drain_filter)]
#![feature(if_let_guard)]
#![feature(is_sorted)]
+#![feature(let_chains)]
#![feature(let_else)]
#![feature(min_specialization)]
-#![feature(nll)]
-#![feature(try_blocks)]
#![feature(never_type)]
-#![feature(slice_partition_dedup)]
-#![feature(control_flow_enum)]
-#![feature(hash_drain_filter)]
+#![feature(nll)]
#![feature(once_cell)]
+#![feature(slice_partition_dedup)]
+#![feature(try_blocks)]
#![recursion_limit = "256"]
-#![allow(rustc::potential_query_instability)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_typeck/src/outlives/implicit_infer.rs b/compiler/rustc_typeck/src/outlives/implicit_infer.rs
index 89f0bd8d421..61ca09f6b98 100644
--- a/compiler/rustc_typeck/src/outlives/implicit_infer.rs
+++ b/compiler/rustc_typeck/src/outlives/implicit_infer.rs
@@ -304,13 +304,12 @@ pub fn check_explicit_predicates<'tcx>(
// = X` binding from the object type (there must be such a
// binding) and thus infer an outlives requirement that `X:
// 'b`.
- if let Some(self_ty) = ignored_self_ty {
- if let GenericArgKind::Type(ty) = outlives_predicate.0.unpack() {
- if ty.walk().any(|arg| arg == self_ty.into()) {
- debug!("skipping self ty = {:?}", &ty);
- continue;
- }
- }
+ if let Some(self_ty) = ignored_self_ty
+ && let GenericArgKind::Type(ty) = outlives_predicate.0.unpack()
+ && ty.walk().any(|arg| arg == self_ty.into())
+ {
+ debug!("skipping self ty = {:?}", &ty);
+ continue;
}
let predicate = outlives_predicate.subst(tcx, substs);