Auto merge of #125602 - RalfJung:interpret-mir-lifetime, r=oli-obk

interpret: get rid of 'mir lifetime
I realized our MIR bodies are actually at lifetime `'tcx`, so we don't need to carry around this other lifetime everywhere.
r? `@oli-obk`

Author: bors

compiler/rustc_const_eval/src/const_eval/dummy_machine.rs

@@ -44,20 +44,20 @@ impl HasStaticRootDefId for DummyMachine {
 }
 }
 
-impl<'mir,'tcx:'mir> interpret::Machine<'mir,'tcx>forDummyMachine{
- interpret::compile_time_machine!(<'mir,'tcx>);
+impl<'tcx> interpret::Machine<'tcx>forDummyMachine{
+ interpret::compile_time_machine!(<'tcx>);
 typeMemoryKind = !;
 constPANIC_ON_ALLOC_FAIL:bool = true;
 
 // We want to just eval random consts in the program, so `eval_mir_const` can fail.
 constALL_CONSTS_ARE_PRECHECKED:bool = false;
 
 #[inline(always)]
-fnenforce_alignment(_ecx:&InterpCx<'mir,'tcx,Self>) -> bool{
+fnenforce_alignment(_ecx:&InterpCx<'tcx,Self>) -> bool{
 false// no reason to enforce alignment
 }
 
-fnenforce_validity(_ecx:&InterpCx<'mir,'tcx,Self>,_layout:TyAndLayout<'tcx>) -> bool{
+fnenforce_validity(_ecx:&InterpCx<'tcx,Self>,_layout:TyAndLayout<'tcx>) -> bool{
 false
 }
 
@@ -83,26 +83,26 @@ impl<'mir, 'tcx: 'mir> interpret::Machine<'mir, 'tcx> for DummyMachine {
 }
 
 fnfind_mir_or_eval_fn(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
+_ecx:&mutInterpCx<'tcx,Self>,
 _instance: ty::Instance<'tcx>,
 _abi: rustc_target::spec::abi::Abi,
 _args:&[interpret::FnArg<'tcx,Self::Provenance>],
 _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!()
 }
 
 fnpanic_nounwind(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
+_ecx:&mutInterpCx<'tcx,Self>,
 _msg:&str,
 ) -> interpret::InterpResult<'tcx>{
 unimplemented!()
 }
 
 fncall_intrinsic(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
+_ecx:&mutInterpCx<'tcx,Self>,
 _instance: ty::Instance<'tcx>,
 _args:&[interpret::OpTy<'tcx,Self::Provenance>],
 _destination:&interpret::MPlaceTy<'tcx,Self::Provenance>,
@@ -113,15 +113,15 @@ impl<'mir, 'tcx: 'mir> interpret::Machine<'mir, 'tcx> for DummyMachine {
 }
 
 fnassert_panic(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
+_ecx:&mutInterpCx<'tcx,Self>,
 _msg:&rustc_middle::mir::AssertMessage<'tcx>,
 _unwind:UnwindAction,
 ) -> interpret::InterpResult<'tcx>{
 unimplemented!()
 }
 
 fnbinary_ptr_op(
-ecx:&InterpCx<'mir,'tcx,Self>,
+ecx:&InterpCx<'tcx,Self>,
 bin_op:BinOp,
 left:&interpret::ImmTy<'tcx,Self::Provenance>,
 right:&interpret::ImmTy<'tcx,Self::Provenance>,
@@ -168,32 +168,30 @@ impl<'mir, 'tcx: 'mir> interpret::Machine<'mir, 'tcx> for DummyMachine {
 }
 
 fnexpose_ptr(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
+_ecx:&mutInterpCx<'tcx,Self>,
 _ptr: interpret::Pointer<Self::Provenance>,
 ) -> interpret::InterpResult<'tcx>{
 unimplemented!()
 }
 
 fninit_frame_extra(
-_ecx:&mutInterpCx<'mir,'tcx,Self>,
-_frame: interpret::Frame<'mir,'tcx,Self::Provenance>,
-) -> interpret::InterpResult<
-'tcx,
- interpret::Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>,
->{
+_ecx:&mutInterpCx<'tcx,Self>,
+_frame: interpret::Frame<'tcx,Self::Provenance>,
+) -> interpret::InterpResult<'tcx, interpret::Frame<'tcx,Self::Provenance,Self::FrameExtra>>
+{
 unimplemented!()
 }
 
 fnstack<'a>(
-_ecx:&'aInterpCx<'mir,'tcx,Self>,
-) -> &'a[interpret::Frame<'mir,'tcx,Self::Provenance,Self::FrameExtra>]{
+_ecx:&'aInterpCx<'tcx,Self>,
+) -> &'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>>{
+_ecx:&'amutInterpCx<'tcx,Self>,
+) -> &'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

@@ -31,10 +31,10 @@ use crate::CTRL_C_RECEIVED;
 
 // Returns a pointer to where the result lives
 #[instrument(level = "trace", skip(ecx, body))]
-fneval_body_using_ecx<'mir,'tcx,R:InterpretationResult<'tcx>>(
-ecx:&mutCompileTimeEvalContext<'mir,'tcx>,
+fneval_body_using_ecx<'tcx,R:InterpretationResult<'tcx>>(
+ecx:&mutCompileTimeEvalContext<'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;
@@ -134,12 +134,12 @@ fn eval_body_using_ecx<'mir, 'tcx, R: InterpretationResult<'tcx>>(
 /// that inform us about the generic bounds of the constant. E.g., using an associated constant
 /// of a function's generic parameter will require knowledge about the bounds on the generic
 /// parameter. These bounds are passed to `mk_eval_cx` via the `ParamEnv` argument.
-pub(crate)fnmk_eval_cx_to_read_const_val<'mir,'tcx>(
+pub(crate)fnmk_eval_cx_to_read_const_val<'tcx>(
 tcx:TyCtxt<'tcx>,
 root_span:Span,
 param_env: ty::ParamEnv<'tcx>,
 can_access_mut_global:CanAccessMutGlobal,
-) -> CompileTimeEvalContext<'mir,'tcx>{
+) -> CompileTimeEvalContext<'tcx>{
 debug!("mk_eval_cx: {:?}", param_env);
 InterpCx::new(
  tcx,
@@ -151,12 +151,12 @@ pub(crate) fn mk_eval_cx_to_read_const_val<'mir, 'tcx>(
 
 /// Create an interpreter context to inspect the given `ConstValue`.
 /// Returns both the context and an `OpTy` that represents the constant.
-pubfnmk_eval_cx_for_const_val<'mir,'tcx>(
+pubfnmk_eval_cx_for_const_val<'tcx>(
 tcx:TyCtxtAt<'tcx>,
 param_env: ty::ParamEnv<'tcx>,
 val: mir::ConstValue<'tcx>,
 ty:Ty<'tcx>,
-) -> Option<(CompileTimeEvalContext<'mir,'tcx>,OpTy<'tcx>)>{
+) -> Option<(CompileTimeEvalContext<'tcx>,OpTy<'tcx>)>{
 let ecx = mk_eval_cx_to_read_const_val(tcx.tcx, tcx.span, param_env,CanAccessMutGlobal::No);
 let op = ecx.const_val_to_op(val, ty,None).ok()?;
 Some((ecx, op))
@@ -170,7 +170,7 @@ pub fn mk_eval_cx_for_const_val<'mir, 'tcx>(
 /// encounter an `Indirect` they cannot handle.
 #[instrument(skip(ecx), level = "debug")]
 pub(super)fnop_to_const<'tcx>(
-ecx:&CompileTimeEvalContext<'_,'tcx>,
+ecx:&CompileTimeEvalContext<'tcx>,
 op:&OpTy<'tcx>,
 for_diagnostics:bool,
 ) -> ConstValue<'tcx>{
@@ -326,16 +326,16 @@ pub trait InterpretationResult<'tcx> {
 /// This function takes the place where the result of the evaluation is stored
 /// and prepares it for returning it in the appropriate format needed by the specific
 /// evaluation query.
-fnmake_result<'mir>(
+fnmake_result(
 mplace:MPlaceTy<'tcx>,
-ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+ecx:&mutInterpCx<'tcx,CompileTimeInterpreter<'tcx>>,
 ) -> Self;
 }
 
 impl<'tcx>InterpretationResult<'tcx>forConstAlloc<'tcx>{
-fnmake_result<'mir>(
+fnmake_result(
 mplace:MPlaceTy<'tcx>,
-_ecx:&mutInterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+_ecx:&mutInterpCx<'tcx,CompileTimeInterpreter<'tcx>>,
 ) -> Self{
 ConstAlloc{alloc_id: mplace.ptr().provenance.unwrap().alloc_id(),ty: mplace.layout.ty}
 }
@@ -416,8 +416,8 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
 }
 
 #[inline(always)]
-fnconst_validate_mplace<'mir,'tcx>(
-ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+fnconst_validate_mplace<'tcx>(
+ecx:&InterpCx<'tcx,CompileTimeInterpreter<'tcx>>,
 mplace:&MPlaceTy<'tcx>,
 cid:GlobalId<'tcx>,
 ) -> Result<(),ErrorHandled>{
@@ -446,8 +446,8 @@ fn const_validate_mplace<'mir, 'tcx>(
 }
 
 #[inline(always)]
-fnreport_validation_error<'mir,'tcx>(
-ecx:&InterpCx<'mir,'tcx,CompileTimeInterpreter<'mir,'tcx>>,
+fnreport_validation_error<'tcx>(
+ecx:&InterpCx<'tcx,CompileTimeInterpreter<'tcx>>,
 error:InterpErrorInfo<'tcx>,
 alloc_id:AllocId,
 ) -> ErrorHandled{