Simplify some nested if statements

compiler/rustc_ast_lowering/src/index.rs

@@ -78,26 +78,24 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
  // Make sure that the DepNode of some node coincides with the HirId
  // owner of that node.
- if cfg!(debug_assertions) {
- if hir_id.owner != self.owner {
- span_bug!(
- span,
- "inconsistent HirId at `{:?}` for `{:?}`: \
+ if cfg!(debug_assertions) && hir_id.owner != self.owner {
+ span_bug!(
+ span,
+ "inconsistent HirId at `{:?}` for `{:?}`: \
  current_dep_node_owner={} ({:?}), hir_id.owner={} ({:?})",
- self.tcx.sess.source_map().span_to_diagnostic_string(span),
- node,
- self.tcx
- .definitions_untracked()
- .def_path(self.owner.def_id)
- .to_string_no_crate_verbose(),
- self.owner,
- self.tcx
- .definitions_untracked()
- .def_path(hir_id.owner.def_id)
- .to_string_no_crate_verbose(),
- hir_id.owner,
- )
- }
+ self.tcx.sess.source_map().span_to_diagnostic_string(span),
+ node,
+ self.tcx
+ .definitions_untracked()
+ .def_path(self.owner.def_id)
+ .to_string_no_crate_verbose(),
+ self.owner,
+ self.tcx
+ .definitions_untracked()
+ .def_path(hir_id.owner.def_id)
+ .to_string_no_crate_verbose(),
+ hir_id.owner,
+ )
  }
 
  self.nodes[hir_id.local_id] = ParentedNode { parent: self.parent_node, node };

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -447,13 +447,13 @@ impl<'a> AstValidator<'a> {
  fn check_item_safety(&self, span: Span, safety: Safety) {
  match self.extern_mod_safety {
  Some(extern_safety) => {
- if matches!(safety, Safety::Unsafe(_) | Safety::Safe(_)) {
- if extern_safety == Safety::Default {
-  self.dcx().emit_err(errors::InvalidSafetyOnExtern {
-  item_span: span,
-  block: Some(self.current_extern_span().shrink_to_lo()),
- });
- }
+ if matches!(safety, Safety::Unsafe(_) | Safety::Safe(_))
+ && extern_safety == Safety::Default
+ {
+ self.dcx().emit_err(errors::InvalidSafetyOnExtern {
+ item_span: span,
+ block: Some(self.current_extern_span().shrink_to_lo()),
+ });
  }
  }
  None => {

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -2574,33 +2574,31 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
  }
  impl<'hir> Visitor<'hir> for ExpressionFinder<'hir> {
  fn visit_expr(&mut self, e: &'hir hir::Expr<'hir>) {
- if e.span.contains(self.capture_span) {
- if let hir::ExprKind::Closure(&hir::Closure {
+ if e.span.contains(self.capture_span)
+ && let hir::ExprKind::Closure(&hir::Closure {
  kind: hir::ClosureKind::Closure,
  body,
  fn_arg_span,
  fn_decl: hir::FnDecl { inputs, .. },
  ..
  }) = e.kind
- && let hir::Node::Expr(body) = self.tcx.hir_node(body.hir_id)
- {
- self.suggest_arg = "this: &Self".to_string();
- if inputs.len() > 0 {
- self.suggest_arg.push_str(", ");
- }
- self.in_closure = true;
- self.closure_arg_span = fn_arg_span;
- self.visit_expr(body);
- self.in_closure = false;
+ && let hir::Node::Expr(body) = self.tcx.hir_node(body.hir_id)
+ {
+ self.suggest_arg = "this: &Self".to_string();
+ if inputs.len() > 0 {
+ self.suggest_arg.push_str(", ");
  }
+ self.in_closure = true;
+ self.closure_arg_span = fn_arg_span;
+ self.visit_expr(body);
+ self.in_closure = false;
  }
- if let hir::Expr { kind: hir::ExprKind::Path(path), .. } = e {
- if let hir::QPath::Resolved(_, hir::Path { segments: [seg], .. }) = path
- && seg.ident.name == kw::SelfLower
- && self.in_closure
- {
- self.closure_change_spans.push(e.span);
- }
+ if let hir::Expr { kind: hir::ExprKind::Path(path), .. } = e
+ && let hir::QPath::Resolved(_, hir::Path { segments: [seg], .. }) = path
+ && seg.ident.name == kw::SelfLower
+ && self.in_closure
+ {
+ self.closure_change_spans.push(e.span);
  }
  hir::intravisit::walk_expr(self, e);
  }
@@ -2609,20 +2607,19 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
  if let hir::Pat { kind: hir::PatKind::Binding(_, hir_id, _ident, _), .. } =
  local.pat
  && let Some(init) = local.init
- {
- if let hir::Expr {
+ && let hir::Expr {
  kind:
  hir::ExprKind::Closure(&hir::Closure {
  kind: hir::ClosureKind::Closure,
  ..
  }),
  ..
  } = init
- && init.span.contains(self.capture_span)
- {
- self.closure_local_id = Some(*hir_id);
- }
+ && init.span.contains(self.capture_span)
+ {
+ self.closure_local_id = Some(*hir_id);
  }
+
  hir::intravisit::walk_local(self, local);
  }
 

compiler/rustc_borrowck/src/lib.rs

@@ -2069,12 +2069,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
  // no move out from an earlier location) then this is an attempt at initialization
  // of the union - we should error in that case.
  let tcx = this.infcx.tcx;
- if base.ty(this.body(), tcx).ty.is_union() {
- if this.move_data.path_map[mpi].iter().any(|moi| {
+ if base.ty(this.body(), tcx).ty.is_union()
+ && this.move_data.path_map[mpi].iter().any(|moi| {
  this.move_data.moves[*moi].source.is_predecessor_of(location, this.body)
- }) {
-  return;
- }
+ })
+ {
+ return;
  }
 
  this.report_use_of_moved_or_uninitialized(

compiler/rustc_borrowck/src/type_check/liveness/trace.rs

@@ -353,11 +353,11 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
  let location = self.cx.elements.to_location(drop_point);
  debug_assert_eq!(self.cx.body.terminator_loc(location.block), location,);
 
- if self.cx.initialized_at_terminator(location.block, mpi) {
- if self.drop_live_at.insert(drop_point) {
-  self.drop_locations.push(location);
-  self.stack.push(drop_point);
- }
+ if self.cx.initialized_at_terminator(location.block, mpi)
+ && self.drop_live_at.insert(drop_point)
+ {
+ self.drop_locations.push(location);
+ self.stack.push(drop_point);
  }
  }
 

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -92,11 +92,9 @@ fn prepare_lto(
  dcx.emit_err(LtoDylib);
  return Err(FatalError);
  }
- } else if *crate_type == CrateType::ProcMacro {
- if !cgcx.opts.unstable_opts.dylib_lto {
- dcx.emit_err(LtoProcMacro);
- return Err(FatalError);
- }
+ } else if *crate_type == CrateType::ProcMacro && !cgcx.opts.unstable_opts.dylib_lto {
+ dcx.emit_err(LtoProcMacro);
+ return Err(FatalError);
  }
  }
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -617,32 +617,29 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  // purpose functions as they wouldn't have the right target features
  // enabled. For that reason we also forbid #[inline(always)] as it can't be
  // respected.
- if !codegen_fn_attrs.target_features.is_empty() {
-  if codegen_fn_attrs.inline == InlineAttr::Always {
-  if let Some(span) = inline_span {
-  tcx.dcx().span_err(
-  span,
-  "cannot use `#[inline(always)]` with \
+ if !codegen_fn_attrs.target_features.is_empty() && codegen_fn_attrs.inline == InlineAttr::Always
+ {
+ if let Some(span) = inline_span {
+ tcx.dcx().span_err(
+ span,
+ "cannot use `#[inline(always)]` with \
  `#[target_feature]`",
- );
- }
+ );
  }
  }
 
- if !codegen_fn_attrs.no_sanitize.is_empty() {
- if codegen_fn_attrs.inline == InlineAttr::Always {
- if let (Some(no_sanitize_span), Some(inline_span)) = (no_sanitize_span, inline_span) {
- let hir_id = tcx.local_def_id_to_hir_id(did);
- tcx.node_span_lint(
- lint::builtin::INLINE_NO_SANITIZE,
- hir_id,
- no_sanitize_span,
- |lint| {
- lint.primary_message("`no_sanitize` will have no effect after inlining");
- lint.span_note(inline_span, "inlining requested here");
- },
- )
- }
+ if !codegen_fn_attrs.no_sanitize.is_empty() && codegen_fn_attrs.inline == InlineAttr::Always {
+ if let (Some(no_sanitize_span), Some(inline_span)) = (no_sanitize_span, inline_span) {
+ let hir_id = tcx.local_def_id_to_hir_id(did);
+ tcx.node_span_lint(
+ lint::builtin::INLINE_NO_SANITIZE,
+ hir_id,
+ no_sanitize_span,
+ |lint| {
+ lint.primary_message("`no_sanitize` will have no effect after inlining");
+ lint.span_note(inline_span, "inlining requested here");
+ },
+ )
  }
  }
 

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -16,7 +16,7 @@ use rustc_span::Span;
 use rustc_target::abi::call::FnAbi;
 use rustc_target::abi::{Align, HasDataLayout, Size, TargetDataLayout};
 use rustc_trait_selection::traits::ObligationCtxt;
-use tracing::{debug, trace};
+use tracing::{debug, instrument, trace};
 
 use super::{
  err_inval, throw_inval, throw_ub, throw_ub_custom, Frame, FrameInfo, GlobalId, InterpErrorInfo,
@@ -315,6 +315,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
  /// Check if the two things are equal in the current param_env, using an infctx to get proper
  /// equality checks.
+ #[instrument(level = "trace", skip(self), ret)]
  pub(super) fn eq_in_param_env<T>(&self, a: T, b: T) -> bool
  where
  T: PartialEq + TypeFoldable<TyCtxt<'tcx>> + ToTrace<'tcx>,
@@ -330,13 +331,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  // equate the two trait refs after normalization
  let a = ocx.normalize(&cause, self.param_env, a);
  let b = ocx.normalize(&cause, self.param_env, b);
- if ocx.eq(&cause, self.param_env, a, b).is_ok() {
- if ocx.select_all_or_error().is_empty() {
- // All good.
- return true;
- }
+
+ if let Err(terr) = ocx.eq(&cause, self.param_env, a, b) {
+ trace!(?terr);
+ return false;
+ }
+
+ let errors = ocx.select_all_or_error();
+ if !errors.is_empty() {
+ trace!(?errors);
+ return false;
  }
- return false;
+
+ // All good.
+ true
  }
 
  /// Walks up the callstack from the intrinsic's callsite, searching for the first callsite in a

compiler/rustc_driver_impl/src/pretty.rs

@@ -222,10 +222,8 @@ impl<'tcx> PrintExtra<'tcx> {
 }
 
 pub fn print<'tcx>(sess: &Session, ppm: PpMode, ex: PrintExtra<'tcx>) {
- if ppm.needs_analysis() {
- if ex.tcx().analysis(()).is_err() {
- FatalError.raise();
- }
+ if ppm.needs_analysis() && ex.tcx().analysis(()).is_err() {
+ FatalError.raise();
  }
 
  let (src, src_name) = get_source(sess);

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -186,17 +186,15 @@ fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: LocalDefId) {
 
  if let Ok(alloc) = tcx.eval_static_initializer(id.to_def_id())
  && alloc.inner().provenance().ptrs().len() != 0
- {
- if attrs
+ && attrs
  .link_section
  .map(|link_section| !link_section.as_str().starts_with(".init_array"))
  .unwrap()
-  {
-  let msg = "statics with a custom `#[link_section]` must be a \
+ {
+ let msg = "statics with a custom `#[link_section]` must be a \
  simple list of bytes on the wasm target with no \
  extra levels of indirection such as references";
- tcx.dcx().span_err(tcx.def_span(id), msg);
- }
+ tcx.dcx().span_err(tcx.def_span(id), msg);
  }
 }
 

compiler/rustc_hir_analysis/src/coherence/mod.rs

@@ -53,17 +53,15 @@ fn enforce_trait_manually_implementable(
 ) -> Result<(), ErrorGuaranteed> {
  let impl_header_span = tcx.def_span(impl_def_id);
 
- if tcx.is_lang_item(trait_def_id, LangItem::Freeze) {
- if !tcx.features().freeze_impls {
- feature_err(
- &tcx.sess,
- sym::freeze_impls,
- impl_header_span,
- "explicit impls for the `Freeze` trait are not permitted",
- )
- .with_span_label(impl_header_span, format!("impl of `Freeze` not allowed"))
- .emit();
- }
+ if tcx.is_lang_item(trait_def_id, LangItem::Freeze) && !tcx.features().freeze_impls {
+ feature_err(
+ &tcx.sess,
+ sym::freeze_impls,
+ impl_header_span,
+ "explicit impls for the `Freeze` trait are not permitted",
+ )
+ .with_span_label(impl_header_span, format!("impl of `Freeze` not allowed"))
+ .emit();
  }
 
  // Disallow *all* explicit impls of traits marked `#[rustc_deny_explicit_impl]`

compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs

@@ -827,20 +827,18 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
 
  if num_generic_args_supplied_to_trait + num_assoc_fn_excess_args
  == num_trait_generics_except_self
+ && let Some(span) = self.gen_args.span_ext()
+ && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span)
  {
- if let Some(span) = self.gen_args.span_ext()
- && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span)
- {
- let sugg = vec![
- (
- self.path_segment.ident.span,
- format!("{}::{}", snippet, self.path_segment.ident),
- ),
- (span.with_lo(self.path_segment.ident.span.hi()), "".to_owned()),
- ];
+ let sugg = vec![
+ (
+ self.path_segment.ident.span,
+ format!("{}::{}", snippet, self.path_segment.ident),
+ ),
+ (span.with_lo(self.path_segment.ident.span.hi()), "".to_owned()),
+ ];
 
- err.multipart_suggestion(msg, sugg, Applicability::MaybeIncorrect);
- }
+ err.multipart_suggestion(msg, sugg, Applicability::MaybeIncorrect);
  }
  }
  }

compiler/rustc_hir_typeck/src/cast.rs

@@ -732,12 +732,11 @@ impl<'a, 'tcx> CastCheck<'tcx> {
  }
  _ => return Err(CastError::NonScalar),
  };
- if let ty::Adt(adt_def, _) = *self.expr_ty.kind() {
- if adt_def.did().krate != LOCAL_CRATE {
- if adt_def.variants().iter().any(VariantDef::is_field_list_non_exhaustive) {
- return Err(CastError::ForeignNonExhaustiveAdt);
- }
- }
+ if let ty::Adt(adt_def, _) = *self.expr_ty.kind()
+ && adt_def.did().krate != LOCAL_CRATE
+ && adt_def.variants().iter().any(VariantDef::is_field_list_non_exhaustive)
+ {
+ return Err(CastError::ForeignNonExhaustiveAdt);
  }
  match (t_from, t_cast) {
  // These types have invariants! can't cast into them.