Add back the third parameter to Evaluator

Summary:
This actually existed before and was removed > 3 years ago with the reasoning:

"It didn't really let you do anything more, since the value was &'a
AnyLifetime<'e>, so 'e couldn't outlive 'a. At the same time, you could pick
the 'a freely, so you didn't ever need them to be different."

That's only true though when the type we put there is covariant in 'e. If it's
invariant (like if it holds a `RefCell<&'e mut X>`) then it cannot fit easily there without
a separate lifetime.

Reviewed By: JakobDegen

Differential Revision: D54214064

fbshipit-source-id: 162e12e007f794c0ea3aaaaf2af4f281e8ca396d

Author: cjhopman

starlark/src/assert/assert.rs

@@ -139,7 +139,7 @@ fn asserts_star(builder: &mut crate::environment::GlobalsBuilder) {
     fn fails<'v>(
         f: Value<'v>,
         msg: &str,
-        eval: &mut Evaluator<'v, '_>,
+        eval: &mut Evaluator<'v, '_, '_>,
     ) -> anyhow::Result<NoneType> {
         let _ = msg;
         match f.invoke_pos(&[], eval) {

starlark/src/debug/adapter/implementation.rs

@@ -87,7 +87,7 @@ struct DapAdapterEvalHookImpl {
 
 fn evaluate_expr<'v>(
     state: &SharedAdapterState,
-    eval: &mut Evaluator<'v, '_>,
+    eval: &mut Evaluator<'v, '_, '_>,
     expr: String,
 ) -> anyhow::Result<Value<'v>> {
     // We don't want to trigger breakpoints during an evaluate,
@@ -106,8 +106,8 @@ fn evaluate_expr<'v>(
     res
 }
 
-impl<'a> BeforeStmtFuncDyn<'a> for DapAdapterEvalHookImpl {
-    fn call<'v>(&mut self, span_loc: FileSpanRef, eval: &mut Evaluator<'v, 'a>) {
+impl<'a, 'e: 'a> BeforeStmtFuncDyn<'a, 'e> for DapAdapterEvalHookImpl {
+    fn call<'v>(&mut self, span_loc: FileSpanRef, eval: &mut Evaluator<'v, 'a, 'e>) {
         let stop = if self.state.disable_breakpoints.load(Ordering::SeqCst) > 0 {
             false
         } else {
@@ -175,7 +175,7 @@ impl DapAdapterEvalHookImpl {
 }
 
 impl DapAdapterEvalHook for DapAdapterEvalHookImpl {
-    fn add_dap_hooks<'v, 'a>(self: Box<Self>, eval: &mut Evaluator<'v, 'a>) {
+    fn add_dap_hooks(self: Box<Self>, eval: &mut Evaluator<'_, '_, '_>) {
         eval.before_stmt_for_dap((self as Box<dyn BeforeStmtFuncDyn>).into());
     }
 }

starlark/src/debug/adapter/mod.rs

@@ -431,7 +431,7 @@ pub fn resolve_breakpoints(
 /// things there).
 pub trait DapAdapterEvalHook: Debug + Send + 'static {
     /// Hooks the evaluator for this DapAdapter.
-    fn add_dap_hooks<'v, 'a>(self: Box<Self>, eval: &mut Evaluator<'v, 'a>);
+    fn add_dap_hooks(self: Box<Self>, eval: &mut Evaluator<'_, '_, '_>);
 }
 
 /// The DAP capabilities that the adapter supports.

starlark/src/debug/evaluate.rs

@@ -23,7 +23,7 @@ use crate::syntax::AstModule;
 use crate::values::FrozenStringValue;
 use crate::values::Value;
 
-impl<'v, 'a> Evaluator<'v, 'a> {
+impl<'v> Evaluator<'v, '_, '_> {
     /// Evaluate statements in the existing context. This function is designed for debugging,
     /// not production use.
     ///
@@ -121,7 +121,7 @@ mod tests {
     fn debugger(builder: &mut GlobalsBuilder) {
         fn debug_evaluate<'v>(
             code: String,
-            eval: &mut Evaluator<'v, '_>,
+            eval: &mut Evaluator<'v, '_, '_>,
         ) -> anyhow::Result<Value<'v>> {
             let ast = AstModule::parse("interactive", code, &Dialect::Extended)
                 .map_err(crate::Error::into_anyhow)?;

starlark/src/debug/inspect.rs

@@ -33,7 +33,7 @@ pub(crate) fn to_scope_names_by_local_slot_id<'v>(x: Value<'v>) -> Option<&'v [F
     }
 }
 
-impl<'v, 'a> Evaluator<'v, 'a> {
+impl<'v> Evaluator<'v, '_, '_> {
     /// Obtain the local variables currently in scope. When at top-level these will be
     /// [`Module`](crate::environment::Module) variables, otherwise local definitions. The precise number of variables
     /// may change over time due to optimisation. The only legitimate use of this function is for debugging.
@@ -42,7 +42,9 @@ impl<'v, 'a> Evaluator<'v, 'a> {
     }
 }
 
-fn inspect_local_variables<'v>(eval: &Evaluator<'v, '_>) -> Option<SmallMap<String, Value<'v>>> {
+fn inspect_local_variables<'v>(
+    eval: &Evaluator<'v, '_, '_>,
+) -> Option<SmallMap<String, Value<'v>>> {
     // First we find the first entry on the call_stack which contains a Def (and thus has locals)
     let xs = eval.call_stack.to_function_values();
     let names = xs
@@ -62,7 +64,7 @@ fn inspect_local_variables<'v>(eval: &Evaluator<'v, '_>) -> Option<SmallMap<Stri
     Some(res)
 }
 
-fn inspect_module_variables<'v>(eval: &Evaluator<'v, '_>) -> SmallMap<String, Value<'v>> {
+fn inspect_module_variables<'v>(eval: &Evaluator<'v, '_, '_>) -> SmallMap<String, Value<'v>> {
     let mut res = SmallMap::new();
     for (name, slot) in eval.module_env.mutable_names().all_names_and_slots() {
         if let Some(v) = eval.module_env.slots().get_slot(slot) {
@@ -91,7 +93,9 @@ mod tests {
             Ok(eval.call_stack().into_frames().map(ToString::to_string))
         }
 
-        fn debug_inspect_variables<'v>(eval: &mut Evaluator<'v, '_>) -> anyhow::Result<Dict<'v>> {
+        fn debug_inspect_variables<'v>(
+            eval: &mut Evaluator<'v, '_, '_>,
+        ) -> anyhow::Result<Dict<'v>> {
             let mut sm = SmallMap::new();
             for (k, v) in eval.local_variables() {
                 sm.insert_hashed(eval.heap().alloc_str(&k).get_hashed(), v);

starlark/src/eval/bc/bytecode.rs

@@ -94,7 +94,7 @@ impl Bc {
     #[inline(always)]
     pub(crate) fn run<'v, EC: EvaluationCallbacks>(
         &self,
-        eval: &mut Evaluator<'v, '_>,
+        eval: &mut Evaluator<'v, '_, '_>,
         ec: &mut EC,
     ) -> Result<Value<'v>, EvalException> {
         debug_assert!(eval.current_frame.is_inititalized());
@@ -117,21 +117,21 @@ impl Bc {
 /// Execute one instruction.
 #[cfg_attr(not(debug_assertions), inline(always))]
 fn step<'v, 'b, EC: EvaluationCallbacks>(
-    eval: &mut Evaluator<'v, '_>,
+    eval: &mut Evaluator<'v, '_, '_>,
     ec: &mut EC,
     frame: BcFramePtr<'v>,
     ip: BcPtrAddr<'b>,
 ) -> InstrControl<'v, 'b> {
     let opcode = ip.get_opcode();
     // println!("{}: {:?}", self.current_ip, opcode);
 
-    struct HandlerImpl<'v, 'a, 'y, 'b> {
-        eval: &'y mut Evaluator<'v, 'a>,
+    struct HandlerImpl<'v, 'a, 'e, 'y, 'b> {
+        eval: &'y mut Evaluator<'v, 'a, 'e>,
         frame: BcFramePtr<'v>,
         ip: BcPtrAddr<'b>,
     }
 
-    impl<'v, 'a, 'y, 'b> BcOpcodeHandler<InstrControl<'v, 'b>> for HandlerImpl<'v, 'a, 'y, 'b> {
+    impl<'v, 'a, 'e, 'y, 'b> BcOpcodeHandler<InstrControl<'v, 'b>> for HandlerImpl<'v, 'a, 'e, 'y, 'b> {
         #[cfg_attr(not(debug_assertions), inline(always))]
         fn handle<I: BcInstr>(self) -> InstrControl<'v, 'b> {
             let HandlerImpl { eval, frame, ip } = self;
@@ -147,7 +147,7 @@ fn step<'v, 'b, EC: EvaluationCallbacks>(
 /// Execute the code block, either a module, a function body or a loop body.
 // Do not inline this function because it is called from two places: function and loop.
 pub(crate) fn run_block<'v, EC: EvaluationCallbacks>(
-    eval: &mut Evaluator<'v, '_>,
+    eval: &mut Evaluator<'v, '_, '_>,
     ec: &mut EC,
     mut ip: BcPtrAddr,
 ) -> Result<Value<'v>, EvalException> {

starlark/src/eval/bc/frame.rs

@@ -319,12 +319,12 @@ unsafe impl<'v> Trace<'v> for BcFramePtr<'v> {
 }
 
 #[inline(always)]
-fn alloca_raw<'v, 'a, R>(
-    eval: &mut Evaluator<'v, 'a>,
+fn alloca_raw<'v, 'a, 'e, R>(
+    eval: &mut Evaluator<'v, 'a, 'e>,
     local_count: u32,
     max_stack_size: u32,
     max_loop_depth: LoopDepth,
-    k: impl FnOnce(&mut Evaluator<'v, 'a>, BcFramePtr<'v>) -> R,
+    k: impl FnOnce(&mut Evaluator<'v, 'a, 'e>, BcFramePtr<'v>) -> R,
 ) -> R {
     assert_eq!(mem::align_of::<BcFrame>() % mem::size_of::<usize>(), 0);
     assert_eq!(mem::size_of::<Value>(), mem::size_of::<usize>());
@@ -349,12 +349,12 @@ fn alloca_raw<'v, 'a, R>(
 ///
 /// After callback finishes, previous frame is restored.
 #[inline(always)]
-pub(crate) fn alloca_frame<'v, 'a, R>(
-    eval: &mut Evaluator<'v, 'a>,
+pub(crate) fn alloca_frame<'v, 'a, 'e, R>(
+    eval: &mut Evaluator<'v, 'a, 'e>,
     local_count: u32,
     max_stack_size: u32,
     loop_depth: LoopDepth,
-    k: impl FnOnce(&mut Evaluator<'v, 'a>) -> R,
+    k: impl FnOnce(&mut Evaluator<'v, 'a, 'e>) -> R,
 ) -> R {
     alloca_raw(
         eval,

starlark/src/eval/bc/instr.rs

@@ -44,7 +44,7 @@ pub(crate) trait BcInstr: Sized + 'static {
 
     /// Execute the instruction.
     fn run<'v, 'b>(
-        eval: &mut Evaluator<'v, '_>,
+        eval: &mut Evaluator<'v, '_, '_>,
         frame: BcFramePtr<'v>,
         ip: BcPtrAddr<'b>,
         arg: &Self::Arg,