lifetimes: access_owned_frozen_value in a couple places

Summary: Things that stopped compiling later in this stack because they weren't statically proving that the reference to the frozen heap had been added

Reviewed By: cjhopman

Differential Revision: D90475059

fbshipit-source-id: 17b3cc15209ef72c314ca47d452ea1952589dcfd

Author: JakobDegen

starlark/src/assert/assert.rs

@@ -59,9 +59,9 @@ static ASSERTS_STAR: Lazy<FrozenModule> = Lazy::new(|| {
     let g = GlobalsBuilder::new()
         .with_namespace("asserts", asserts_star)
         .build();
-    Module::with_temp_heap(|m| {
-        m.frozen_heap().add_reference(g.heap());
-        let asserts = g.get("asserts").unwrap();
+    Module::with_temp_heap(move |m| {
+        let asserts = g.get_owned("asserts").unwrap();
+        let asserts = m.heap().access_owned_frozen_value(&asserts);
         m.set("asserts", asserts);
         m.set(
             "freeze",

starlark/src/environment/globals.rs

@@ -40,7 +40,7 @@ use crate::values::FrozenHeap;
 use crate::values::FrozenHeapRef;
 use crate::values::FrozenStringValue;
 use crate::values::FrozenValue;
-use crate::values::Value;
+use crate::values::OwnedFrozenValue;
 use crate::values::function::NativeFunc;
 use crate::values::function::NativeFuncFn;
 use crate::values::function::SpecialBuiltinFunction;
@@ -114,7 +114,8 @@ impl Globals {
 
     /// This function is only safe if you first call `heap` and keep a reference to it.
     /// Therefore, don't expose it on the public API.
-    pub(crate) fn get<'v>(&'v self, name: &str) -> Option<Value<'v>> {
+    #[cfg(test)]
+    pub(crate) fn get<'v>(&'v self, name: &str) -> Option<crate::values::Value<'v>> {
         self.get_frozen(name).map(FrozenValue::to_value)
     }
 
@@ -124,6 +125,12 @@ impl Globals {
         self.0.variables.get_str(name).map(|x| x.value)
     }
 
+    pub(crate) fn get_owned(&self, name: &str) -> Option<OwnedFrozenValue> {
+        let v = self.get_frozen(name)?;
+        // SAFETY: We know the heap this is allocated in
+        unsafe { Some(OwnedFrozenValue::new(self.heap().dupe(), v)) }
+    }
+
     /// Get all the names defined in this environment.
     pub fn names(&self) -> impl Iterator<Item = FrozenStringValue> + '_ {
         self.0.variable_names.iter().copied()

starlark/src/environment/modules.rs

@@ -535,7 +535,7 @@ impl Module {
             ));
         }
         match module.get_any_visibility(symbol)? {
-            (v, Visibility::Public) => Ok(v.owned_value(self.frozen_heap())),
+            (v, Visibility::Public) => Ok(self.heap().access_owned_frozen_value(&v)),
             (_, Visibility::Private) => Err(crate::Error::new_other(
                 EnvironmentError::ModuleSymbolIsNotExported(symbol.to_owned()),
             )),

starlark/src/tests/def.rs

@@ -172,8 +172,10 @@ value = {"test": "hello"}
     let f = m.get("function").unwrap();
     let x = m.get("value").unwrap();
     Module::with_temp_heap(|module| {
+        let f = module.heap().access_owned_frozen_value(&f);
+        let x = module.heap().access_owned_frozen_value(&x);
         let mut eval = Evaluator::new(&module);
-        let res = eval.eval_function(f.value(), &[x.value()], &[]).unwrap();
+        let res = eval.eval_function(f, &[x], &[]).unwrap();
         assert_eq!(res.to_str(), "hello");
         crate::Result::Ok(())
     })