Remove unneeded field from SwitchTargets

compiler/rustc_borrowck/src/invalidation.rs

@@ -106,7 +106,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
  self.check_activations(location);
 
  match &terminator.kind {
- TerminatorKind::SwitchInt { ref discr, switch_ty: _, targets: _ } => {
+ TerminatorKind::SwitchInt { ref discr, targets: _ } => {
  self.consume_operand(location, discr);
  }
  TerminatorKind::Drop { place: drop_place, target: _, unwind: _ } => {

compiler/rustc_borrowck/src/lib.rs

@@ -644,7 +644,7 @@ impl<'cx, 'tcx> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtx
  self.check_activations(loc, span, flow_state);
 
  match term.kind {
- TerminatorKind::SwitchInt { ref discr, switch_ty: _, targets: _ } => {
+ TerminatorKind::SwitchInt { ref discr, targets: _ } => {
  self.consume_operand(loc, (discr, span), flow_state);
  }
  TerminatorKind::Drop { place, target: _, unwind: _ } => {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1360,25 +1360,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  );
  }
  }
- TerminatorKind::SwitchInt { ref discr, switch_ty, .. } => {
+ TerminatorKind::SwitchInt { ref discr, .. } => {
  self.check_operand(discr, term_location);
 
- let discr_ty = discr.ty(body, tcx);
- if let Err(terr) = self.sub_types(
- discr_ty,
- switch_ty,
- term_location.to_locations(),
- ConstraintCategory::Assignment,
- ) {
- span_mirbug!(
- self,
- term,
- "bad SwitchInt ({:?} on {:?}): {:?}",
- switch_ty,
- discr_ty,
- terr
- );
- }
+ let switch_ty = discr.ty(body, tcx);
  if !switch_ty.is_integral() && !switch_ty.is_char() && !switch_ty.is_bool() {
  span_mirbug!(self, term, "bad SwitchInt discr ty {:?}", switch_ty);
  }

compiler/rustc_codegen_cranelift/src/base.rs

@@ -372,8 +372,10 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
  }
  }
 
- TerminatorKind::SwitchInt { discr, switch_ty, targets } => {
- let discr = codegen_operand(fx, discr).load_scalar(fx);
+ TerminatorKind::SwitchInt { discr, targets } => {
+ let discr = codegen_operand(fx, discr);
+ let switch_ty = discr.layout().ty;
+ let discr = discr.load_scalar(fx);
 
  let use_bool_opt = switch_ty.kind() == fx.tcx.types.bool.kind()
  || (targets.iter().count() == 1 && targets.iter().next().unwrap().0 == 0);

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -307,12 +307,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  helper: TerminatorCodegenHelper<'tcx>,
  bx: &mut Bx,
  discr: &mir::Operand<'tcx>,
- switch_ty: Ty<'tcx>,
  targets: &SwitchTargets,
  ) {
  let discr = self.codegen_operand(bx, &discr);
- // `switch_ty` is redundant, sanity-check that.
- assert_eq!(discr.layout.ty, switch_ty);
+ let switch_ty = discr.layout.ty;
  let mut target_iter = targets.iter();
  if target_iter.len() == 1 {
  // If there are two targets (one conditional, one fallback), emit `br` instead of
@@ -1293,8 +1291,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  helper.funclet_br(self, bx, target, mergeable_succ())
  }
 
- mir::TerminatorKind::SwitchInt { ref discr, switch_ty, ref targets } => {
- self.codegen_switchint_terminator(helper, bx, discr, switch_ty, targets);
+ mir::TerminatorKind::SwitchInt { ref discr, ref targets } => {
+ self.codegen_switchint_terminator(helper, bx, discr, targets);
  MergingSucc::False
  }
 

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -29,10 +29,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
  Goto { target } => self.go_to_block(target),
 
- SwitchInt { ref discr, ref targets, switch_ty } => {
+ SwitchInt { ref discr, ref targets } => {
  let discr = self.read_immediate(&self.eval_operand(discr, None)?)?;
  trace!("SwitchInt({:?})", *discr);
- assert_eq!(discr.layout.ty, switch_ty);
 
  // Branch to the `otherwise` case by default, if no match is found.
  let mut target_block = targets.otherwise();

compiler/rustc_const_eval/src/transform/validate.rs

@@ -682,17 +682,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  TerminatorKind::Goto { target } => {
  self.check_edge(location, *target, EdgeKind::Normal);
  }
- TerminatorKind::SwitchInt { targets, switch_ty, discr } => {
- let ty = discr.ty(&self.body.local_decls, self.tcx);
- if ty != *switch_ty {
- self.fail(
- location,
- format!(
- "encountered `SwitchInt` terminator with type mismatch: {:?} != {:?}",
- ty, switch_ty,
- ),
- );
- }
+ TerminatorKind::SwitchInt { targets, discr } => {
+ let switch_ty = discr.ty(&self.body.local_decls, self.tcx);
 
  let target_width = self.tcx.sess.target.pointer_width;
 

compiler/rustc_middle/src/mir/syntax.rs

@@ -505,12 +505,6 @@ pub enum TerminatorKind<'tcx> {
  SwitchInt {
  /// The discriminant value being tested.
  discr: Operand<'tcx>,
-
- /// The type of value being tested.
- /// This is always the same as the type of `discr`.
- /// FIXME: remove this redundant information. Currently, it is relied on by pretty-printing.
- switch_ty: Ty<'tcx>,
-
  targets: SwitchTargets,
  },
 

compiler/rustc_middle/src/mir/terminator.rs

@@ -1,6 +1,3 @@
-use crate::mir;
-use crate::mir::interpret::Scalar;
-use crate::ty::{self, Ty, TyCtxt};
 use smallvec::{smallvec, SmallVec};
 
 use super::{BasicBlock, InlineAsmOperand, Operand, SourceInfo, TerminatorKind};
@@ -131,17 +128,8 @@ impl<'tcx> Terminator<'tcx> {
 }
 
 impl<'tcx> TerminatorKind<'tcx> {
- pub fn if_(
- tcx: TyCtxt<'tcx>,
- cond: Operand<'tcx>,
- t: BasicBlock,
- f: BasicBlock,
- ) -> TerminatorKind<'tcx> {
- TerminatorKind::SwitchInt {
- discr: cond,
- switch_ty: tcx.types.bool,
- targets: SwitchTargets::static_if(0, f, t),
- }
+ pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {
+ TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }
  }
 
  pub fn successors(&self) -> Successors<'_> {
@@ -264,11 +252,9 @@ impl<'tcx> TerminatorKind<'tcx> {
  }
  }
 
- pub fn as_switch(&self) -> Option<(&Operand<'tcx>, Ty<'tcx>, &SwitchTargets)> {
+ pub fn as_switch(&self) -> Option<(&Operand<'tcx>, &SwitchTargets)> {
  match self {
- TerminatorKind::SwitchInt { discr, switch_ty, targets } => {
- Some((discr, *switch_ty, targets))
- }
+ TerminatorKind::SwitchInt { discr, targets } => Some((discr, targets)),
  _ => None,
  }
  }
@@ -403,21 +389,12 @@ impl<'tcx> TerminatorKind<'tcx> {
  match *self {
  Return | Resume | Abort | Unreachable | GeneratorDrop => vec![],
  Goto { .. } => vec!["".into()],
- SwitchInt { ref targets, switch_ty, .. } => ty::tls::with(|tcx| {
- let param_env = ty::ParamEnv::empty();
- let switch_ty = tcx.lift(switch_ty).unwrap();
- let size = tcx.layout_of(param_env.and(switch_ty)).unwrap().size;
- targets
- .values
- .iter()
- .map(|&u| {
- mir::ConstantKind::from_scalar(tcx, Scalar::from_uint(u, size), switch_ty)
- .to_string()
- .into()
- })
- .chain(iter::once("otherwise".into()))
- .collect()
- }),
+ SwitchInt { ref targets, .. } => targets
+ .values
+ .iter()
+ .map(|&u| Cow::Owned(u.to_string()))
+ .chain(iter::once("otherwise".into()))
+ .collect(),
  Call { target: Some(_), cleanup: Some(_), .. } => {
  vec!["return".into(), "unwind".into()]
  }

compiler/rustc_middle/src/mir/visit.rs

@@ -477,11 +477,9 @@ macro_rules! make_mir_visitor {
 
  TerminatorKind::SwitchInt {
  discr,
- switch_ty,
  targets: _
  } => {
  self.visit_operand(discr, location);
- self.visit_ty($(& $mutability)? *switch_ty, TyContext::Location(location));
  }
 
  TerminatorKind::Drop {

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -183,7 +183,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  LogicalOp::And => (else_block, shortcircuit_block),
  LogicalOp::Or => (shortcircuit_block, else_block),
  };
- let term = TerminatorKind::if_(this.tcx, lhs, blocks.0, blocks.1);
+ let term = TerminatorKind::if_(lhs, blocks.0, blocks.1);
  this.cfg.terminate(block, source_info, term);
 
  this.cfg.push_assign_constant(

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -95,7 +95,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
  let then_block = this.cfg.start_new_block();
  let else_block = this.cfg.start_new_block();
- let term = TerminatorKind::if_(this.tcx, operand, then_block, else_block);
+ let term = TerminatorKind::if_(operand, then_block, else_block);
 
  let source_info = this.source_info(expr_span);
  this.cfg.terminate(block, source_info, term);

compiler/rustc_mir_build/src/build/matches/test.rs

@@ -203,7 +203,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  self.source_info(match_start_span),
  TerminatorKind::SwitchInt {
  discr: Operand::Move(discr),
- switch_ty: discr_ty,
  targets: switch_targets,
  },
  );
@@ -221,7 +220,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  0 => (second_bb, first_bb),
  v => span_bug!(test.span, "expected boolean value but got {:?}", v),
  };
- TerminatorKind::if_(self.tcx, Operand::Copy(place), true_bb, false_bb)
+ TerminatorKind::if_(Operand::Copy(place), true_bb, false_bb)
  } else {
  // The switch may be inexhaustive so we have a catch all block
  debug_assert_eq!(options.len() + 1, target_blocks.len());
@@ -232,7 +231,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  );
  TerminatorKind::SwitchInt {
  discr: Operand::Copy(place),
- switch_ty,
  targets: switch_targets,
  }
  };
@@ -378,7 +376,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  self.cfg.terminate(
  block,
  source_info,
- TerminatorKind::if_(self.tcx, Operand::Move(result), success_block, fail_block),
+ TerminatorKind::if_(Operand::Move(result), success_block, fail_block),
  );
  }
 
@@ -482,7 +480,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  self.cfg.terminate(
  eq_block,
  source_info,
- TerminatorKind::if_(self.tcx, Operand::Move(eq_result), success_block, fail_block),
+ TerminatorKind::if_(Operand::Move(eq_result), success_block, fail_block),
  );
  }
 

compiler/rustc_mir_dataflow/src/elaborate_drops.rs

@@ -596,7 +596,6 @@ where
  source_info: self.source_info,
  kind: TerminatorKind::SwitchInt {
  discr: Operand::Move(discr),
- switch_ty: discr_ty,
  targets: SwitchTargets::new(
  values.iter().copied().zip(blocks.iter().copied()),
  *blocks.last().unwrap(),
@@ -716,7 +715,7 @@ where
  is_cleanup: unwind.is_cleanup(),
  terminator: Some(Terminator {
  source_info: self.source_info,
- kind: TerminatorKind::if_(tcx, move_(can_go), succ, drop_block),
+ kind: TerminatorKind::if_(move_(can_go), succ, drop_block),
  }),
  };
  let loop_block = self.elaborator.patch().new_block(loop_block);
@@ -781,7 +780,6 @@ where
  source_info: self.source_info,
  kind: TerminatorKind::SwitchInt {
  discr: move_(elem_size),
- switch_ty: tcx.types.usize,
  targets: SwitchTargets::static_if(
  0,
  self.drop_loop_pair(ety, false, len),
@@ -1021,7 +1019,7 @@ where
  DropStyle::Static => on_set,
  DropStyle::Conditional | DropStyle::Open => {
  let flag = self.elaborator.get_drop_flag(self.path).unwrap();
- let term = TerminatorKind::if_(self.tcx(), flag, on_set, on_unset);
+ let term = TerminatorKind::if_(flag, on_set, on_unset);
  self.new_block(unwind, term)
  }
  }

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -261,7 +261,7 @@ impl Direction for Backward {
  propagate(pred, &tmp);
  }
 
- mir::TerminatorKind::SwitchInt { targets: _, ref discr, switch_ty: _ } => {
+ mir::TerminatorKind::SwitchInt { targets: _, ref discr } => {
  let mut applier = BackwardSwitchIntEdgeEffectsApplier {
  body,
  pred,
@@ -577,7 +577,7 @@ impl Direction for Forward {
  }
  }
 
- SwitchInt { ref targets, ref discr, switch_ty: _ } => {
+ SwitchInt { ref targets, ref discr } => {
  let mut applier = ForwardSwitchIntEdgeEffectsApplier {
  exit_state,
  targets,

compiler/rustc_mir_transform/src/const_goto.rs

@@ -82,8 +82,9 @@ impl<'tcx> Visitor<'tcx> for ConstGotoOptimizationFinder<'_, 'tcx> {
  }
 
  let target_bb_terminator = target_bb.terminator();
- let (discr, switch_ty, targets) = target_bb_terminator.kind.as_switch()?;
+ let (discr, targets) = target_bb_terminator.kind.as_switch()?;
  if discr.place() == Some(*place) {
+ let switch_ty = place.ty(self.body.local_decls(), self.tcx).ty;
  // We now know that the Switch matches on the const place, and it is statementless
  // Now find which value in the Switch matches the const value.
  let const_value =

compiler/rustc_mir_transform/src/coverage/tests.rs

@@ -37,7 +37,7 @@ use rustc_data_structures::graph::WithSuccessors;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_middle::mir::coverage::CoverageKind;
 use rustc_middle::mir::*;
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty;
 use rustc_span::{self, BytePos, Pos, Span, DUMMY_SP};
 
 // All `TEMP_BLOCK` targets should be replaced before calling `to_body() -> mir::Body`.
@@ -47,7 +47,6 @@ struct MockBlocks<'tcx> {
  blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
  dummy_place: Place<'tcx>,
  next_local: usize,
- bool_ty: Ty<'tcx>,
 }
 
 impl<'tcx> MockBlocks<'tcx> {
@@ -56,7 +55,6 @@ impl<'tcx> MockBlocks<'tcx> {
  blocks: IndexVec::new(),
  dummy_place: Place { local: RETURN_PLACE, projection: ty::List::empty() },
  next_local: 0,
- bool_ty: TyCtxt::BOOL_TY_FOR_UNIT_TESTING,
  }
  }
 
@@ -157,7 +155,6 @@ impl<'tcx> MockBlocks<'tcx> {
  fn switchint(&mut self, some_from_block: Option<BasicBlock>) -> BasicBlock {
  let switchint_kind = TerminatorKind::SwitchInt {
  discr: Operand::Move(Place::from(self.new_temp())),
- switch_ty: self.bool_ty, // just a dummy value
  targets: SwitchTargets::static_if(0, TEMP_BLOCK, TEMP_BLOCK),
  };
  self.add_block_from(some_from_block, switchint_kind)