prepare_fn_for_call → eval_callee_and_args, +EvaluatedCalleeAndArgs

Small refactor required by review.

Author: WaffleLapkin

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -42,6 +42,15 @@ impl<'tcx, Prov: Provenance> FnArg<'tcx, Prov> {
     }
 }
 
+struct EvaluatedCalleeAndArgs<'tcx, 'mir, M: Machine<'mir, 'tcx>> {
+    callee: FnVal<'tcx, M::ExtraFnVal>,
+    args: Vec<FnArg<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>>,
+    fn_sig: ty::FnSig<'tcx>,
+    fn_abi: &'tcx FnAbi<'tcx, Ty<'tcx>>,
+    /// True if the function is marked as `#[track_caller]` ([`ty::InstanceDef::requires_caller_location`])
+    with_caller_location: bool,
+}
+
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// Make a copy of the given fn_arg. Any `InPlace` are degenerated to copies, no protection of the
     /// original memory occurs.
@@ -123,12 +132,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let old_stack = self.frame_idx();
                 let old_loc = self.frame().loc;
 
-                let (fn_val, args, fn_sig, fn_abi, with_caller_location) =
-                    self.prepare_fn_for_call(terminator, func, args)?;
+                let EvaluatedCalleeAndArgs { callee, args, fn_sig, fn_abi, with_caller_location } =
+                    self.eval_callee_and_args(terminator, func, args)?;
 
                 let destination = self.eval_place(destination)?;
                 self.eval_fn_call(
-                    fn_val,
+                    callee,
                     (fn_sig.abi, fn_abi),
                     &args,
                     with_caller_location,
@@ -146,8 +155,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             TailCall { ref func, ref args, fn_span: _ } => {
                 let old_frame_idx = self.frame_idx();
 
-                let (fn_val, args, fn_sig, fn_abi, with_caller_location) =
-                    self.prepare_fn_for_call(terminator, func, args)?;
+                let EvaluatedCalleeAndArgs { callee, args, fn_sig, fn_abi, with_caller_location } =
+                    self.eval_callee_and_args(terminator, func, args)?;
 
                 // This is the "canonical" implementation of tails calls,
                 // a pop of the current stack frame, followed by a normal call
@@ -170,7 +179,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 };
 
                 self.eval_fn_call(
-                    fn_val,
+                    callee,
                     (fn_sig.abi, fn_abi),
                     &args,
                     with_caller_location,
@@ -507,22 +516,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     }
 
     /// Shared part of `Call` and `TailCall` implementation — finding and evaluating all the
-    /// necessary information about callee to make a call.
-    fn prepare_fn_for_call(
+    /// necessary information about callee and arguments to make a call.
+    fn eval_callee_and_args(
         &self,
         terminator: &mir::Terminator<'tcx>,
         func: &mir::Operand<'tcx>,
         args: &[Spanned<mir::Operand<'tcx>>],
-    ) -> InterpResult<
-        'tcx,
-        (
-            FnVal<'tcx, M::ExtraFnVal>,
-            Vec<FnArg<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>>,
-            ty::FnSig<'tcx>,
-            &'tcx FnAbi<'tcx, Ty<'tcx>>,
-            bool,
-        ),
-    > {
+    ) -> InterpResult<'tcx, EvaluatedCalleeAndArgs<'tcx, 'mir, M>> {
         let func = self.eval_operand(func, None)?;
         let args = self.eval_fn_call_arguments(args)?;
 
@@ -532,7 +532,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let extra_args =
             self.tcx.mk_type_list_from_iter(extra_args.iter().map(|arg| arg.layout().ty));
 
-        let (fn_val, fn_abi, with_caller_location) = match *func.layout.ty.kind() {
+        let (callee, fn_abi, with_caller_location) = match *func.layout.ty.kind() {
             ty::FnPtr(_sig) => {
                 let fn_ptr = self.read_pointer(&func)?;
                 let fn_val = self.get_ptr_fn(fn_ptr)?;
@@ -551,7 +551,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
         };
 
-        Ok((fn_val, args, fn_sig, fn_abi, with_caller_location))
+        Ok(EvaluatedCalleeAndArgs { callee, args, fn_sig, fn_abi, with_caller_location })
     }
 
     /// Call this function -- pushing the stack frame and initializing the arguments.