interpret: the MIR is actually at lifetime 'tcx

Author: RalfJung

compiler/rustc_const_eval/src/const_eval/dummy_machine.rs

@@ -90,7 +90,7 @@ impl<'mir, 'tcx: 'mir> interpret::Machine<'mir, 'tcx> for DummyMachine {
 _destination:&interpret::MPlaceTy<'tcx,Self::Provenance>,
 _target:Option<BasicBlock>,
 _unwind:UnwindAction,
-) -> interpret::InterpResult<'tcx,Option<(&'mirBody<'tcx>, ty::Instance<'tcx>)>>{
+) -> interpret::InterpResult<'tcx,Option<(&'tcxBody<'tcx>, ty::Instance<'tcx>)>>{
 unimplemented!()
 }
 
@@ -176,24 +176,24 @@ impl<'mir, 'tcx: 'mir> interpret::Machine<'mir, 'tcx> for DummyMachine {
 
 fninit_frame_extra(
 _ecx:&mutInterpCx<'mir,'tcx,Self>,
-_frame: interpret::Frame<'mir,'tcx,Self::Provenance>,
+_frame: interpret::Frame<'tcx,Self::Provenance>,
 ) -> interpret::InterpResult<
 'tcx,
- interpret::Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>,
+ interpret::Frame<'tcx,Self::Provenance,Self::FrameExtra>,
 >{
 unimplemented!()
 }
 
 fnstack<'a>(
 _ecx:&'aInterpCx<'mir,'tcx,Self>,
-) -> &'a[interpret::Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>]{
+) -> &'a[interpret::Frame<'tcx,Self::Provenance,Self::FrameExtra>]{
 // Return an empty stack instead of panicking, as `cur_span` uses it to evaluate constants.
 &[]
 }
 
 fnstack_mut<'a>(
 _ecx:&'amutInterpCx<'mir,'tcx,Self>,
-) -> &'amutVec<interpret::Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>>{
+) -> &'amutVec<interpret::Frame<'tcx,Self::Provenance,Self::FrameExtra>>{
 unimplemented!()
 }
 }

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -58,13 +58,10 @@ impl<'tcx> Into<InterpErrorInfo<'tcx>> for ConstEvalErrKind {
 }
 }
 
-pubfnget_span_and_frames<'tcx,'mir>(
+pubfnget_span_and_frames<'tcx>(
 tcx:TyCtxtAt<'tcx>,
-stack:&[Frame<'mir,'tcx,implProvenance,implSized>],
-) -> (Span,Vec<errors::FrameNote>)
-where
-'tcx:'mir,
-{
+stack:&[Frame<'tcx,implProvenance,implSized>],
+) -> (Span,Vec<errors::FrameNote>){
 letmut stacktrace = Frame::generate_stacktrace_from_stack(stack);
 // Filter out `requires_caller_location` frames.
  stacktrace.retain(|frame| !frame.instance.def.requires_caller_location(*tcx));
@@ -161,9 +158,9 @@ where
 
 /// Emit a lint from a const-eval situation.
 // Even if this is unused, please don't remove it -- chances are we will need to emit a lint during const-eval again in the future!
-pub(super)fnlint<'tcx,'mir,L>(
+pub(super)fnlint<'tcx,L>(
 tcx:TyCtxtAt<'tcx>,
-machine:&CompileTimeInterpreter<'mir,'tcx>,
+machine:&CompileTimeInterpreter<'tcx>,
 lint:&'static rustc_session::lint::Lint,
 decorator:implFnOnce(Vec<errors::FrameNote>) -> L,
 )where

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -34,7 +34,7 @@ use crate::CTRL_C_RECEIVED;
 fneval_body_using_ecx<'mir,'tcx,R:InterpretationResult<'tcx>>(
 ecx:&mutCompileTimeEvalContext<'mir,'tcx>,
 cid:GlobalId<'tcx>,
-body:&'mir mir::Body<'tcx>,
+body:&'tcx mir::Body<'tcx>,
 ) -> InterpResult<'tcx,R>{
 trace!(?ecx.param_env);
 let tcx = *ecx.tcx;
@@ -328,14 +328,14 @@ pub trait InterpretationResult<'tcx> {
 /// evaluation query.
 fnmake_result<'mir>(
 mplace:MPlaceTy<'tcx>,
-ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>,
 ) -> Self;
 }
 
 impl<'tcx>InterpretationResult<'tcx>forConstAlloc<'tcx>{
 fnmake_result<'mir>(
 mplace:MPlaceTy<'tcx>,
-_ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+_ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>,
 ) -> Self{
 ConstAlloc{alloc_id: mplace.ptr().provenance.unwrap().alloc_id(),ty: mplace.layout.ty}
 }
@@ -417,7 +417,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
 
 #[inline(always)]
 fnconst_validate_mplace<'mir,'tcx>(
-ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>,
 mplace:&MPlaceTy<'tcx>,
 cid:GlobalId<'tcx>,
 ) -> Result<(),ErrorHandled>{
@@ -447,7 +447,7 @@ fn const_validate_mplace<'mir, 'tcx>(
 
 #[inline(always)]
 fnreport_validation_error<'mir,'tcx>(
-ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>,
 error:InterpErrorInfo<'tcx>,
 alloc_id:AllocId,
 ) -> ErrorHandled{

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -45,15 +45,15 @@ const TINY_LINT_TERMINATOR_LIMIT: usize = 20;
 constPROGRESS_INDICATOR_START:usize = 4_000_000;
 
 /// Extra machine state for CTFE, and the Machine instance
-pubstructCompileTimeInterpreter<'mir,'tcx>{
+pubstructCompileTimeInterpreter<'tcx>{
 /// The number of terminators that have been evaluated.
 ///
 /// This is used to produce lints informing the user that the compiler is not stuck.
 /// Set to `usize::MAX` to never report anything.
 pub(super)num_evaluated_steps:usize,
 
 /// The virtual call stack.
-pub(super)stack:Vec<Frame<'mir,'tcx>>,
+pub(super)stack:Vec<Frame<'tcx>>,
 
 /// Pattern matching on consts with references would be unsound if those references
 /// could point to anything mutable. Therefore, when evaluating consts and when constructing valtrees,
@@ -90,7 +90,7 @@ impl From<bool> for CanAccessMutGlobal {
 }
 }
 
-impl<'mir,'tcx>CompileTimeInterpreter<'mir,'tcx>{
+impl<'tcx>CompileTimeInterpreter<'tcx>{
 pub(crate)fnnew(
 can_access_mut_global:CanAccessMutGlobal,
 check_alignment:CheckAlignment,
@@ -165,7 +165,7 @@ impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxIndexMap<K, V> {
 }
 
 pub(crate)typeCompileTimeEvalContext<'mir,'tcx> =
-InterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>;
+InterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>;
 
 #[derive(Debug,PartialEq,Eq,Copy,Clone)]
 pubenumMemoryKind{
@@ -371,7 +371,7 @@ impl<'mir, 'tcx: 'mir> CompileTimeEvalContext<'mir, 'tcx> {
 }
 }
 
-impl<'mir,'tcx> interpret::Machine<'mir,'tcx>forCompileTimeInterpreter<'mir,'tcx>{
+impl<'mir,'tcx:'mir> interpret::Machine<'mir,'tcx>forCompileTimeInterpreter<'tcx>{
 compile_time_machine!(<'mir,'tcx>);
 
 typeMemoryKind = MemoryKind;
@@ -417,7 +417,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
 dest:&MPlaceTy<'tcx>,
 ret:Option<mir::BasicBlock>,
 _unwind: mir::UnwindAction,// unwinding is not supported in consts
-) -> InterpResult<'tcx,Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>>{
+) -> InterpResult<'tcx,Option<(&'tcx mir::Body<'tcx>, ty::Instance<'tcx>)>>{
 debug!("find_mir_or_eval_fn: {:?}", orig_instance);
 
 // Replace some functions.
@@ -658,8 +658,8 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
 #[inline(always)]
 fninit_frame_extra(
 ecx:&mutInterpCx<'mir,'tcx,Self>,
-frame:Frame<'mir,'tcx>,
-) -> InterpResult<'tcx,Frame<'mir,'tcx>>{
+frame:Frame<'tcx>,
+) -> InterpResult<'tcx,Frame<'tcx>>{
 // Enforce stack size limit. Add 1 because this is run before the new frame is pushed.
 if !ecx.recursion_limit.value_within_limit(ecx.stack().len() + 1){
 throw_exhaust!(StackFrameLimitReached)
@@ -671,14 +671,14 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
 #[inline(always)]
 fnstack<'a>(
 ecx:&'aInterpCx<'mir,'tcx,Self>,
-) -> &'a[Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>]{
+) -> &'a[Frame<'tcx,Self::Provenance,Self::FrameExtra>]{
 &ecx.machine.stack
 }
 
 #[inline(always)]
 fnstack_mut<'a>(
 ecx:&'amutInterpCx<'mir,'tcx,Self>,
-) -> &'amutVec<Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>>{
+) -> &'amutVec<Frame<'tcx,Self::Provenance,Self::FrameExtra>>{
 &mut ecx.machine.stack
 }
 

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -90,12 +90,12 @@ impl Drop for SpanGuard {
 }
 
 /// A stack frame.
-pubstructFrame<'mir,'tcx,Prov:Provenance = CtfeProvenance,Extra = ()>{
+pubstructFrame<'tcx,Prov:Provenance = CtfeProvenance,Extra = ()>{
 ////////////////////////////////////////////////////////////////////////////////
 // Function and callsite information
 ////////////////////////////////////////////////////////////////////////////////
 /// The MIR for the function called on this frame.
-pubbody:&'mir mir::Body<'tcx>,
+pubbody:&'tcx mir::Body<'tcx>,
 
 /// The def_id and args of the current function.
 pubinstance: ty::Instance<'tcx>,
@@ -232,8 +232,8 @@ impl<'tcx, Prov: Provenance> LocalState<'tcx, Prov> {
 }
 }
 
-impl<'mir,'tcx,Prov:Provenance>Frame<'mir,'tcx,Prov>{
-pubfnwith_extra<Extra>(self,extra:Extra) -> Frame<'mir,'tcx,Prov,Extra>{
+impl<'tcx,Prov:Provenance>Frame<'tcx,Prov>{
+pubfnwith_extra<Extra>(self,extra:Extra) -> Frame<'tcx,Prov,Extra>{
 Frame{
 body:self.body,
 instance:self.instance,
@@ -247,7 +247,7 @@ impl<'mir, 'tcx, Prov: Provenance> Frame<'mir, 'tcx, Prov> {
 }
 }
 
-impl<'mir,'tcx,Prov:Provenance,Extra>Frame<'mir,'tcx,Prov,Extra>{
+impl<'tcx,Prov:Provenance,Extra>Frame<'tcx,Prov,Extra>{
 /// Get the current location within the Frame.
 ///
 /// If this is `Left`, we are not currently executing any particular statement in
@@ -517,14 +517,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 }
 
 #[inline(always)]
-pub(crate)fnstack(&self) -> &[Frame<'mir,'tcx,M::Provenance,M::FrameExtra>]{
+pub(crate)fnstack(&self) -> &[Frame<'tcx,M::Provenance,M::FrameExtra>]{
 M::stack(self)
 }
 
 #[inline(always)]
-pub(crate)fnstack_mut(
-&mutself,
-) -> &mutVec<Frame<'mir,'tcx,M::Provenance,M::FrameExtra>>{
+pub(crate)fnstack_mut(&mutself) -> &mutVec<Frame<'tcx,M::Provenance,M::FrameExtra>>{
 M::stack_mut(self)
 }
 
@@ -536,12 +534,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 }
 
 #[inline(always)]
-pubfnframe(&self) -> &Frame<'mir,'tcx,M::Provenance,M::FrameExtra>{
+pubfnframe(&self) -> &Frame<'tcx,M::Provenance,M::FrameExtra>{
 self.stack().last().expect("no call frames exist")
 }
 
 #[inline(always)]
-pubfnframe_mut(&mutself) -> &mutFrame<'mir,'tcx,M::Provenance,M::FrameExtra>{
+pubfnframe_mut(&mutself) -> &mutFrame<'tcx,M::Provenance,M::FrameExtra>{
 self.stack_mut().last_mut().expect("no call frames exist")
 }
 
@@ -602,7 +600,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 T:TypeFoldable<TyCtxt<'tcx>>,
 >(
 &self,
-frame:&Frame<'mir,'tcx,M::Provenance,M::FrameExtra>,
+frame:&Frame<'tcx,M::Provenance,M::FrameExtra>,
 value:T,
 ) -> Result<T,ErrorHandled>{
  frame
@@ -680,7 +678,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 #[inline(always)]
 pub(super)fnlayout_of_local(
 &self,
-frame:&Frame<'mir,'tcx,M::Provenance,M::FrameExtra>,
+frame:&Frame<'tcx,M::Provenance,M::FrameExtra>,
 local: mir::Local,
 layout:Option<TyAndLayout<'tcx>>,
 ) -> InterpResult<'tcx,TyAndLayout<'tcx>>{
@@ -803,7 +801,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 pubfnpush_stack_frame(
 &mutself,
 instance: ty::Instance<'tcx>,
-body:&'mir mir::Body<'tcx>,
+body:&'tcx mir::Body<'tcx>,
 return_place:&MPlaceTy<'tcx,M::Provenance>,
 return_to_block:StackPopCleanup,
 ) -> InterpResult<'tcx>{

compiler/rustc_const_eval/src/interpret/intern.rs

@@ -46,7 +46,7 @@ pub trait HasStaticRootDefId {
 fnstatic_def_id(&self) -> Option<LocalDefId>;
 }
 
-implHasStaticRootDefIdfor const_eval::CompileTimeInterpreter<'_,'_>{
+implHasStaticRootDefIdfor const_eval::CompileTimeInterpreter<'_>{
 fnstatic_def_id(&self) -> Option<LocalDefId>{
 Some(self.static_root_ids?.1)
 }

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -200,7 +200,7 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
 destination:&MPlaceTy<'tcx,Self::Provenance>,
 target:Option<mir::BasicBlock>,
 unwind: mir::UnwindAction,
-) -> InterpResult<'tcx,Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>>;
+) -> InterpResult<'tcx,Option<(&'tcx mir::Body<'tcx>, ty::Instance<'tcx>)>>;
 
 /// Execute `fn_val`. It is the hook's responsibility to advance the instruction
 /// pointer as appropriate.
@@ -478,18 +478,18 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
 /// Called immediately before a new stack frame gets pushed.
 fninit_frame_extra(
 ecx:&mutInterpCx<'mir,'tcx,Self>,
-frame:Frame<'mir,'tcx,Self::Provenance>,
-) -> InterpResult<'tcx,Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>>;
+frame:Frame<'tcx,Self::Provenance>,
+) -> InterpResult<'tcx,Frame<'tcx,Self::Provenance,Self::FrameExtra>>;
 
 /// Borrow the current thread's stack.
 fnstack<'a>(
 ecx:&'aInterpCx<'mir,'tcx,Self>,
-) -> &'a[Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>];
+) -> &'a[Frame<'tcx,Self::Provenance,Self::FrameExtra>];
 
 /// Mutably borrow the current thread's stack.
 fnstack_mut<'a>(
 ecx:&'amutInterpCx<'mir,'tcx,Self>,
-) -> &'amutVec<Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>>;
+) -> &'amutVec<Frame<'tcx,Self::Provenance,Self::FrameExtra>>;
 
 /// Called immediately after a stack frame got pushed and its locals got initialized.
 fnafter_stack_push(_ecx:&mutInterpCx<'mir,'tcx,Self>) -> InterpResult<'tcx>{
@@ -499,7 +499,7 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
 /// Called just before the return value is copied to the caller-provided return place.
 fnbefore_stack_pop(
 _ecx:&InterpCx<'mir,'tcx,Self>,
-_frame:&Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>,
+_frame:&Frame<'tcx,Self::Provenance,Self::FrameExtra>,
 ) -> InterpResult<'tcx>{
 Ok(())
 }
@@ -509,7 +509,7 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
 #[inline(always)]
 fnafter_stack_pop(
 _ecx:&mutInterpCx<'mir,'tcx,Self>,
-_frame:Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>,
+_frame:Frame<'tcx,Self::Provenance,Self::FrameExtra>,
 unwinding:bool,
 ) -> InterpResult<'tcx,StackPopJump>{
 // By default, we do not support unwinding from panics

compiler/rustc_const_eval/src/interpret/util.rs

@@ -84,7 +84,7 @@ where
 impl<'tcx>InterpretationResult<'tcx>for mir::interpret::ConstAllocation<'tcx>{
 fnmake_result<'mir>(
 mplace:MPlaceTy<'tcx>,
-ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'tcx>>,
 ) -> Self{
 let alloc_id = mplace.ptr().provenance.unwrap().alloc_id();
 let alloc = ecx.memory.alloc_map.swap_remove(&alloc_id).unwrap().1;

src/tools/miri/src/borrow_tracker/mod.rs

@@ -354,7 +354,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
 fnon_stack_pop(
 &self,
-frame:&Frame<'mir,'tcx,Provenance,FrameExtra<'tcx>>,
+frame:&Frame<'tcx,Provenance,FrameExtra<'tcx>>,
 ) -> InterpResult<'tcx>{
 let this = self.eval_context_ref();
 let borrow_tracker = this.machine.borrow_tracker.as_ref().unwrap();