Rollup merge of rust-lang#59430 - kenta7777:rename-evalcontext-to-int…

…erpretcx, r=oli-obk

Renames `EvalContext` to `InterpretCx`

This PR renames `EvalContext` to `InterpretCx` in `src/librustc_mir`.
This PR is related to rust-lang#54395 .

src/librustc/mir/interpret/mod.rs

@@ -344,7 +344,7 @@ impl<'tcx> AllocMap<'tcx> {
  }
  }
 
- /// Returns `None` in case the `AllocId` is dangling. An `EvalContext` can still have a
+ /// Returns `None` in case the `AllocId` is dangling. An `InterpretCx` can still have a
  /// local `Allocation` for that `AllocId`, but having such an `AllocId` in a constant is
  /// illegal and will likely ICE.
  /// This function exists to allow const eval to detect the difference between evaluation-

src/librustc_mir/const_eval.rs

@@ -22,7 +22,7 @@ use syntax::source_map::{Span, DUMMY_SP};
 use crate::interpret::{self,
  PlaceTy, MPlaceTy, MemPlace, OpTy, ImmTy, Immediate, Scalar, Pointer,
  RawConst, ConstValue,
- EvalResult, EvalError, EvalErrorKind, GlobalId, EvalContext, StackPopCleanup,
+ EvalResult, EvalError, EvalErrorKind, GlobalId, InterpretCx, StackPopCleanup,
  Allocation, AllocId, MemoryKind,
  snapshot, RefTracking,
 };
@@ -34,7 +34,7 @@ const STEPS_UNTIL_DETECTOR_ENABLED: isize = 1_000_000;
 /// Should be a power of two for performance reasons.
 const DETECTOR_SNAPSHOT_PERIOD: isize = 256;
 
-/// The `EvalContext` is only meant to be used to do field and index projections into constants for
+/// The `InterpretCx` is only meant to be used to do field and index projections into constants for
 /// `simd_shuffle` and const patterns in match arms.
 ///
 /// The function containing the `match` that is currently being analyzed may have generic bounds
@@ -47,7 +47,7 @@ pub(crate) fn mk_eval_cx<'a, 'mir, 'tcx>(
  param_env: ty::ParamEnv<'tcx>,
 ) -> CompileTimeEvalContext<'a, 'mir, 'tcx> {
  debug!("mk_eval_cx: {:?}", param_env);
- EvalContext::new(tcx.at(span), param_env, CompileTimeInterpreter::new())
+ InterpretCx::new(tcx.at(span), param_env, CompileTimeInterpreter::new())
 }
 
 pub(crate) fn eval_promoted<'a, 'mir, 'tcx>(
@@ -116,7 +116,7 @@ fn eval_body_and_ecx<'a, 'mir, 'tcx>(
  // and try improving it down the road when more information is available
  let span = tcx.def_span(cid.instance.def_id());
  let span = mir.map(|mir| mir.span).unwrap_or(span);
- let mut ecx = EvalContext::new(tcx.at(span), param_env, CompileTimeInterpreter::new());
+ let mut ecx = InterpretCx::new(tcx.at(span), param_env, CompileTimeInterpreter::new());
  let r = eval_body_using_ecx(&mut ecx, cid, mir, param_env);
  (r, ecx)
 }
@@ -292,7 +292,7 @@ impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxHashMap<K, V> {
 }
 
 type CompileTimeEvalContext<'a, 'mir, 'tcx> =
- EvalContext<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>;
+ InterpretCx<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>;
 
 impl interpret::MayLeak for ! {
  #[inline(always)]
@@ -317,12 +317,12 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
  const STATIC_KIND: Option<!> = None; // no copying of statics allowed
 
  #[inline(always)]
- fn enforce_validity(_ecx: &EvalContext<'a, 'mir, 'tcx, Self>) -> bool {
+ fn enforce_validity(_ecx: &InterpretCx<'a, 'mir, 'tcx, Self>) -> bool {
  false // for now, we don't enforce validity
  }
 
  fn find_fn(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  instance: ty::Instance<'tcx>,
  args: &[OpTy<'tcx>],
  dest: Option<PlaceTy<'tcx>>,
@@ -362,7 +362,7 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
  }
 
  fn call_intrinsic(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  instance: ty::Instance<'tcx>,
  args: &[OpTy<'tcx>],
  dest: PlaceTy<'tcx>,
@@ -378,7 +378,7 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
  }
 
  fn ptr_op(
- _ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &InterpretCx<'a, 'mir, 'tcx, Self>,
  _bin_op: mir::BinOp,
  _left: ImmTy<'tcx>,
  _right: ImmTy<'tcx>,
@@ -406,15 +406,15 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
  }
 
  fn box_alloc(
- _ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  _dest: PlaceTy<'tcx>,
  ) -> EvalResult<'tcx> {
  Err(
  ConstEvalError::NeedsRfc("heap allocations via `box` keyword".to_string()).into(),
  )
  }
 
- fn before_terminator(ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx> {
+ fn before_terminator(ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx> {
  {
  let steps = &mut ecx.machine.steps_since_detector_enabled;
 
@@ -440,7 +440,7 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
 
  #[inline(always)]
  fn tag_new_allocation(
- _ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  ptr: Pointer,
  _kind: MemoryKind<Self::MemoryKinds>,
  ) -> Pointer {
@@ -449,15 +449,15 @@ impl<'a, 'mir, 'tcx> interpret::Machine<'a, 'mir, 'tcx>
 
  #[inline(always)]
  fn stack_push(
- _ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  ) -> EvalResult<'tcx> {
  Ok(())
  }
 
  /// Called immediately before a stack frame gets popped.
  #[inline(always)]
  fn stack_pop(
- _ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  _extra: (),
  ) -> EvalResult<'tcx> {
  Ok(())
@@ -504,7 +504,7 @@ pub fn const_variant_index<'a, 'tcx>(
 }
 
 pub fn error_to_const_error<'a, 'mir, 'tcx>(
- ecx: &EvalContext<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>,
+ ecx: &InterpretCx<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>,
  mut error: EvalError<'tcx>
 ) -> ConstEvalErr<'tcx> {
  error.print_backtrace();

src/librustc_mir/interpret/cast.rs

@@ -9,9 +9,9 @@ use rustc::mir::interpret::{
 use rustc::mir::CastKind;
 use rustc_apfloat::Float;
 
-use super::{EvalContext, Machine, PlaceTy, OpTy, ImmTy, Immediate};
+use super::{InterpretCx, Machine, PlaceTy, OpTy, ImmTy, Immediate};
 
-impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
  match ty.sty {
  ty::RawPtr(ty::TypeAndMut { ty, .. }) |

src/librustc_mir/interpret/eval_context.rs

@@ -26,7 +26,7 @@ use super::{
  Memory, Machine
 };
 
-pub struct EvalContext<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'a, 'mir, 'tcx>> {
+pub struct InterpretCx<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'a, 'mir, 'tcx>> {
  /// Stores the `Machine` instance.
  pub machine: M,
 
@@ -141,15 +141,15 @@ impl<'tcx, Tag> LocalState<'tcx, Tag> {
 }
 
 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> HasDataLayout
- for EvalContext<'a, 'mir, 'tcx, M>
+ for InterpretCx<'a, 'mir, 'tcx, M>
 {
  #[inline]
  fn data_layout(&self) -> &layout::TargetDataLayout {
  &self.tcx.data_layout
  }
 }
 
-impl<'a, 'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for EvalContext<'a, 'mir, 'tcx, M>
+impl<'a, 'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for InterpretCx<'a, 'mir, 'tcx, M>
  where M: Machine<'a, 'mir, 'tcx>
 {
  #[inline]
@@ -159,7 +159,7 @@ impl<'a, 'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for EvalContext<'a, 'mir, 'tcx,
 }
 
 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> LayoutOf
- for EvalContext<'a, 'mir, 'tcx, M>
+ for InterpretCx<'a, 'mir, 'tcx, M>
 {
  type Ty = Ty<'tcx>;
  type TyLayout = EvalResult<'tcx, TyLayout<'tcx>>;
@@ -171,13 +171,13 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> LayoutOf
  }
 }
 
-impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  pub fn new(
  tcx: TyCtxtAt<'a, 'tcx, 'tcx>,
  param_env: ty::ParamEnv<'tcx>,
  machine: M,
  ) -> Self {
- EvalContext {
+ InterpretCx {
  machine,
  tcx,
  param_env,

src/librustc_mir/interpret/intrinsics.rs

@@ -11,7 +11,7 @@ use rustc::mir::interpret::{
 };
 
 use super::{
- Machine, PlaceTy, OpTy, EvalContext,
+ Machine, PlaceTy, OpTy, InterpretCx,
 };
 
 
@@ -36,7 +36,7 @@ fn numeric_intrinsic<'tcx, Tag>(
  Ok(Scalar::from_uint(bits_out, size))
 }
 
-impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  /// Returns `true` if emulation happened.
  pub fn emulate_intrinsic(
  &mut self,

src/librustc_mir/interpret/machine.rs

@@ -11,7 +11,7 @@ use rustc::ty::{self, query::TyCtxtAt};
 
 use super::{
  Allocation, AllocId, EvalResult, Scalar, AllocationExtra,
- EvalContext, PlaceTy, MPlaceTy, OpTy, ImmTy, Pointer, MemoryKind,
+ InterpretCx, PlaceTy, MPlaceTy, OpTy, ImmTy, Pointer, MemoryKind,
 };
 
 /// Whether this kind of memory is allowed to leak
@@ -95,11 +95,11 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  const STATIC_KIND: Option<Self::MemoryKinds>;
 
  /// Whether to enforce the validity invariant
- fn enforce_validity(ecx: &EvalContext<'a, 'mir, 'tcx, Self>) -> bool;
+ fn enforce_validity(ecx: &InterpretCx<'a, 'mir, 'tcx, Self>) -> bool;
 
  /// Called before a basic block terminator is executed.
  /// You can use this to detect endlessly running programs.
- fn before_terminator(ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx>;
+ fn before_terminator(ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx>;
 
  /// Entry point to all function calls.
  ///
@@ -112,7 +112,7 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  /// Passing `dest`and `ret` in the same `Option` proved very annoying when only one of them
  /// was used.
  fn find_fn(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  instance: ty::Instance<'tcx>,
  args: &[OpTy<'tcx, Self::PointerTag>],
  dest: Option<PlaceTy<'tcx, Self::PointerTag>>,
@@ -122,7 +122,7 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  /// Directly process an intrinsic without pushing a stack frame.
  /// If this returns successfully, the engine will take care of jumping to the next block.
  fn call_intrinsic(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  instance: ty::Instance<'tcx>,
  args: &[OpTy<'tcx, Self::PointerTag>],
  dest: PlaceTy<'tcx, Self::PointerTag>,
@@ -156,21 +156,21 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  ///
  /// Returns a (value, overflowed) pair if the operation succeeded
  fn ptr_op(
- ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &InterpretCx<'a, 'mir, 'tcx, Self>,
  bin_op: mir::BinOp,
  left: ImmTy<'tcx, Self::PointerTag>,
  right: ImmTy<'tcx, Self::PointerTag>,
  ) -> EvalResult<'tcx, (Scalar<Self::PointerTag>, bool)>;
 
  /// Heap allocations via the `box` keyword.
  fn box_alloc(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  dest: PlaceTy<'tcx, Self::PointerTag>,
  ) -> EvalResult<'tcx>;
 
  /// Adds the tag for a newly allocated pointer.
  fn tag_new_allocation(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  ptr: Pointer,
  kind: MemoryKind<Self::MemoryKinds>,
  ) -> Pointer<Self::PointerTag>;
@@ -180,7 +180,7 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  /// `mutability` can be `None` in case a raw ptr is being dereferenced.
  #[inline]
  fn tag_dereference(
- _ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &InterpretCx<'a, 'mir, 'tcx, Self>,
  place: MPlaceTy<'tcx, Self::PointerTag>,
  _mutability: Option<hir::Mutability>,
  ) -> EvalResult<'tcx, Scalar<Self::PointerTag>> {
@@ -190,7 +190,7 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
  /// Executes a retagging operation
  #[inline]
  fn retag(
- _ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ _ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  _kind: mir::RetagKind,
  _place: PlaceTy<'tcx, Self::PointerTag>,
  ) -> EvalResult<'tcx> {
@@ -199,12 +199,12 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
 
  /// Called immediately before a new stack frame got pushed
  fn stack_push(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  ) -> EvalResult<'tcx, Self::FrameExtra>;
 
  /// Called immediately after a stack frame gets popped
  fn stack_pop(
- ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
+ ecx: &mut InterpretCx<'a, 'mir, 'tcx, Self>,
  extra: Self::FrameExtra,
  ) -> EvalResult<'tcx>;
 }

src/librustc_mir/interpret/mod.rs

@@ -18,7 +18,7 @@ mod visitor;
 pub use rustc::mir::interpret::*; // have all the `interpret` symbols in one place: here
 
 pub use self::eval_context::{
- EvalContext, Frame, StackPopCleanup, LocalState, LocalValue,
+ InterpretCx, Frame, StackPopCleanup, LocalState, LocalValue,
 };
 
 pub use self::place::{Place, PlaceTy, MemPlace, MPlaceTy};

src/librustc_mir/interpret/operand.rs

@@ -13,7 +13,7 @@ use rustc::mir::interpret::{
  sign_extend, truncate,
 };
 use super::{
- EvalContext, Machine,
+ InterpretCx, Machine,
  MemPlace, MPlaceTy, PlaceTy, Place, MemoryKind,
 };
 pub use rustc::mir::interpret::ScalarMaybeUndef;
@@ -267,7 +267,7 @@ pub(super) fn from_known_layout<'tcx>(
  }
 }
 
-impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  /// Try reading an immediate in memory; this is interesting particularly for ScalarPair.
  /// Returns `None` if the layout does not permit loading this as a value.
  fn try_read_immediate_from_mplace(

src/librustc_mir/interpret/operator.rs

@@ -5,10 +5,10 @@ use rustc_apfloat::ieee::{Double, Single};
 use rustc_apfloat::Float;
 use rustc::mir::interpret::{EvalResult, Scalar};
 
-use super::{EvalContext, PlaceTy, Immediate, Machine, ImmTy};
+use super::{InterpretCx, PlaceTy, Immediate, Machine, ImmTy};
 
 
-impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  /// Applies the binary operation `op` to the two operands and writes a tuple of the result
  /// and a boolean signifying the potential overflow to the destination.
  pub fn binop_with_overflow(
@@ -37,7 +37,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
  }
 }
 
-impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
  fn binary_char_op(
  &self,
  bin_op: mir::BinOp,

src/librustc_mir/interpret/place.rs

@@ -14,7 +14,7 @@ use rustc::ty::TypeFoldable;
 
 use super::{
  GlobalId, AllocId, Allocation, Scalar, EvalResult, Pointer, PointerArithmetic,
- EvalContext, Machine, AllocMap, AllocationExtra,
+ InterpretCx, Machine, AllocMap, AllocationExtra,
  RawConst, Immediate, ImmTy, ScalarMaybeUndef, Operand, OpTy, MemoryKind
 };
 
@@ -305,7 +305,7 @@ impl<'tcx, Tag: ::std::fmt::Debug> PlaceTy<'tcx, Tag> {
 }
 
 // separating the pointer tag for `impl Trait`, see https://github.com/rust-lang/rust/issues/54385
-impl<'a, 'mir, 'tcx, Tag, M> EvalContext<'a, 'mir, 'tcx, M>
+impl<'a, 'mir, 'tcx, Tag, M> InterpretCx<'a, 'mir, 'tcx, M>
 where
  // FIXME: Working around https://github.com/rust-lang/rust/issues/54385
  Tag: ::std::fmt::Debug+Default+Copy+Eq+Hash+'static,
@@ -607,7 +607,7 @@ where
  // global table but not in its local memory: It calls back into tcx through
  // a query, triggering the CTFE machinery to actually turn this lazy reference
  // into a bunch of bytes. IOW, statics are evaluated with CTFE even when
- // this EvalContext uses another Machine (e.g., in miri). This is what we
+ // this InterpretCx uses another Machine (e.g., in miri). This is what we
  // want! This way, computing statics works concistently between codegen
  // and miri: They use the same query to eventually obtain a `ty::Const`
  // and use that for further computation.