Various pattern cleanups

Author: LeSeulArtichaut

compiler/rustc_ast/src/mut_visit.rs

@@ -1179,13 +1179,10 @@ fn noop_visit_inline_asm<T: MutVisitor>(asm: &mut InlineAsm, vis: &mut T) {
  for (op, _) in &mut asm.operands {
  match op {
  InlineAsmOperand::In { expr, .. }
+ | InlineAsmOperand::Out { expr: Some(expr), .. }
  | InlineAsmOperand::InOut { expr, .. }
  | InlineAsmOperand::Sym { expr, .. } => vis.visit_expr(expr),
- InlineAsmOperand::Out { expr, .. } => {
- if let Some(expr) = expr {
- vis.visit_expr(expr);
- }
- }
+ InlineAsmOperand::Out { expr: None, .. } => {}
  InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
  vis.visit_expr(in_expr);
  if let Some(out_expr) = out_expr {

compiler/rustc_ast/src/visit.rs

@@ -714,13 +714,10 @@ fn walk_inline_asm<'a, V: Visitor<'a>>(visitor: &mut V, asm: &'a InlineAsm) {
  for (op, _) in &asm.operands {
  match op {
  InlineAsmOperand::In { expr, .. }
+ | InlineAsmOperand::Out { expr: Some(expr), .. }
  | InlineAsmOperand::InOut { expr, .. }
  | InlineAsmOperand::Sym { expr, .. } => visitor.visit_expr(expr),
- InlineAsmOperand::Out { expr, .. } => {
- if let Some(expr) = expr {
- visitor.visit_expr(expr);
- }
- }
+ InlineAsmOperand::Out { expr: None, .. } => {}
  InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
  visitor.visit_expr(in_expr);
  if let Some(out_expr) = out_expr {

compiler/rustc_expand/src/lib.rs

@@ -1,3 +1,4 @@
+#![cfg_attr(bootstrap, feature(bindings_after_at))]
 #![feature(crate_visibility_modifier)]
 #![feature(decl_macro)]
 #![feature(destructuring_assignment)]

compiler/rustc_middle/src/mir/mod.rs

@@ -1664,13 +1664,10 @@ impl Debug for Statement<'_> {
  AscribeUserType(box (ref place, ref c_ty), ref variance) => {
  write!(fmt, "AscribeUserType({:?}, {:?}, {:?})", place, variance, c_ty)
  }
- Coverage(box ref coverage) => {
- if let Some(rgn) = &coverage.code_region {
- write!(fmt, "Coverage::{:?} for {:?}", coverage.kind, rgn)
- } else {
- write!(fmt, "Coverage::{:?}", coverage.kind)
- }
+ Coverage(box self::Coverage { ref kind, code_region: Some(ref rgn) }) => {
+ write!(fmt, "Coverage::{:?} for {:?}", kind, rgn)
  }
+ Coverage(box ref coverage) => write!(fmt, "Coverage::{:?}", coverage.kind),
  CopyNonOverlapping(box crate::mir::CopyNonOverlapping {
  ref src,
  ref dst,

compiler/rustc_middle/src/mir/visit.rs

@@ -587,14 +587,12 @@ macro_rules! make_mir_visitor {
  InlineAsmOperand::In { value, .. } => {
  self.visit_operand(value, location);
  }
- InlineAsmOperand::Out { place, .. } => {
- if let Some(place) = place {
- self.visit_place(
- place,
- PlaceContext::MutatingUse(MutatingUseContext::Store),
- location,
- );
- }
+ InlineAsmOperand::Out { place: Some(place), .. } => {
+ self.visit_place(
+ place,
+ PlaceContext::MutatingUse(MutatingUseContext::Store),
+ location,
+ );
  }
  InlineAsmOperand::InOut { in_value, out_place, .. } => {
  self.visit_operand(in_value, location);
@@ -610,7 +608,8 @@ macro_rules! make_mir_visitor {
  | InlineAsmOperand::SymFn { value } => {
  self.visit_constant(value, location);
  }
- InlineAsmOperand::SymStatic { def_id: _ } => {}
+ InlineAsmOperand::Out { place: None, .. }
+ | InlineAsmOperand::SymStatic { def_id: _ } => {}
  }
  }
  }

compiler/rustc_middle/src/thir.rs

@@ -14,7 +14,7 @@ use rustc_hir::def::CtorKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::RangeEnd;
 use rustc_index::newtype_index;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 use rustc_middle::infer::canonical::Canonical;
 use rustc_middle::middle::region;
 use rustc_middle::mir::{
@@ -716,17 +716,9 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
  PatKind::Variant { adt_def, variant_index, .. } => {
  Some(&adt_def.variants[variant_index])
  }
- _ => {
- if let ty::Adt(adt, _) = self.ty.kind() {
- if !adt.is_enum() {
- Some(&adt.variants[VariantIdx::new(0)])
- } else {
- None
- }
- } else {
- None
- }
- }
+ _ => self.ty.ty_adt_def().and_then(|adt| {
+ if !adt.is_enum() { Some(adt.non_enum_variant()) } else { None }
+ }),
  };
 
  if let Some(variant) = variant {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -927,27 +927,29 @@ pub trait PrettyPrinter<'tcx>:
  }
 
  match ct.val {
- ty::ConstKind::Unevaluated(ty::Unevaluated { def, substs, promoted }) => {
- if let Some(promoted) = promoted {
-  p!(print_value_path(def.did, substs));
-  p!(write("::{:?}", promoted));
-  } else {
-  match self.tcx().def_kind(def.did) {
-  DefKind::Static | DefKind::Const | DefKind::AssocConst => {
-  p!(print_value_path(def.did, substs))
-  }
-  _ => {
-  if def.is_local() {
-  let span = self.tcx().def_span(def.did);
-  if let Ok(snip) = self.tcx().sess.source_map().span_to_snippet(span)
-   {
-  p!(write("{}", snip))
-  } else {
-  print_underscore!()
- }
+ ty::ConstKind::Unevaluated(ty::Unevaluated {
+ def,
+ substs,
+ promoted: Some(promoted),
+ }) => {
+ p!(print_value_path(def.did, substs));
+ p!(write("::{:?}", promoted));
+ }
+ ty::ConstKind::Unevaluated(ty::Unevaluated { def, substs, promoted: None }) => {
+ match self.tcx().def_kind(def.did) {
+ DefKind::Static | DefKind::Const | DefKind::AssocConst => {
+ p!(print_value_path(def.did, substs))
+ }
+ _ => {
+ if def.is_local() {
+ let span = self.tcx().def_span(def.did);
+ if let Ok(snip) = self.tcx().sess.source_map().span_to_snippet(span) {
+ p!(write("{}", snip))
  } else {
  print_underscore!()
  }
+ } else {
+ print_underscore!()
  }
  }
  }

compiler/rustc_typeck/src/check/expr.rs

@@ -2164,14 +2164,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  hir::InlineAsmOperand::In { expr, .. } => {
  self.check_expr_asm_operand(expr, true);
  }
- hir::InlineAsmOperand::Out { expr, .. } => {
- if let Some(expr) = expr {
- self.check_expr_asm_operand(expr, false);
- }
- }
- hir::InlineAsmOperand::InOut { expr, .. } => {
+ hir::InlineAsmOperand::Out { expr: Some(expr), .. }
+ | hir::InlineAsmOperand::InOut { expr, .. } => {
  self.check_expr_asm_operand(expr, false);
  }
+ hir::InlineAsmOperand::Out { expr: None, .. } => {}
  hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
  self.check_expr_asm_operand(in_expr, true);
  if let Some(out_expr) = out_expr {

compiler/rustc_typeck/src/expr_use_visitor.rs

@@ -334,12 +334,8 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
  match op {
  hir::InlineAsmOperand::In { expr, .. }
  | hir::InlineAsmOperand::Sym { expr, .. } => self.consume_expr(expr),
- hir::InlineAsmOperand::Out { expr, .. } => {
- if let Some(expr) = expr {
- self.mutate_expr(expr);
- }
- }
- hir::InlineAsmOperand::InOut { expr, .. } => {
+ hir::InlineAsmOperand::Out { expr: Some(expr), .. }
+ | hir::InlineAsmOperand::InOut { expr, .. } => {
  self.mutate_expr(expr);
  }
  hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
@@ -348,7 +344,8 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
  self.mutate_expr(out_expr);
  }
  }
- hir::InlineAsmOperand::Const { .. } => {}
+ hir::InlineAsmOperand::Out { expr: None, .. }
+ | hir::InlineAsmOperand::Const { .. } => {}
  }
  }
  }