blob: 532346e42dad123dce20ef3ce83d10690b45c188 [file]
// Copyright 2026 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use std::pin::Pin;
use starlark::values::{Heap, Value as StarlarkValue};
use crate::{bridge::Value, Immutable, OwnedSlice, Scope};
impl Scope {
pub(crate) fn new<'b>(
parent: &Self,
keys: &[&str],
) -> (cxx::UniquePtr<Self>, OwnedSlice<Pin<&'b mut Value>>) {
let mut nested_scope = cxx::UniquePtr::<Self>::null();
let values = crate::bridge::NewScope(parent, keys, &mut nested_scope);
(nested_scope, values.into())
}
/// Returns the settings for the given scope.
pub fn settings(&self) -> &crate::Settings {
// Safety: Settings pointer is always valid and non-null.
unsafe { self.settings_cxx().as_ref() }.unwrap()
}
/// Returns the items currently in the scope (not including parent scopes).
pub fn items(&self) -> Immutable<OwnedSlice<crate::bridge::KeyValue<'_>>> {
let slice = crate::bridge::GetScopeItems(self);
Immutable::from(crate::OwnedSlice::<crate::bridge::KeyValue>::from(slice))
}
/// Converts Scope items to Starlark key-value pairs.
pub fn get_kv<'v>(&self, heap: &Heap<'v>) -> Vec<(&str, StarlarkValue<'v>)> {
let owned = self.items();
let mut items = Vec::new();
for pair in owned.as_slice() {
items.push((pair.key, pair.value.to_rust(heap)));
}
items
}
}
pub struct OwnedScope(pub cxx::UniquePtr<Scope>);
impl types::Scope for OwnedScope {
fn copy_with<'a, 'v>(&self, kv: impl Iterator<Item = (&'a str, StarlarkValue<'v>)>) -> Self {
let parent = self.0.as_ref().unwrap();
let (keys, vals): (Vec<&str>, Vec<StarlarkValue<'v>>) = kv.unzip();
let (mut child_scope, mut placeholders) = Scope::new(parent, &keys);
// Safety: The child scope will always be non-null.
let child_ref = unsafe { child_scope.as_mut().unwrap().get_unchecked_mut() };
for (placeholder, val) in placeholders.as_slice_mut().iter_mut().zip(vals) {
placeholder
.as_mut()
.assign(val, child_ref, Default::default());
}
Self(child_scope)
}
fn get<'v>(&self, key: &str, heap: &Heap<'v>) -> Option<StarlarkValue<'v>> {
let parent = self.0.as_ref().unwrap();
let val_ptr = crate::bridge::GetValue(parent, key);
// Safety: val_ptr is either null or a valid pointer backed by the parent scope
// lifetime.
unsafe { val_ptr.as_ref() }.map(|val| val.to_rust(heap))
}
}
#[cfg(test)]
mod tests {
use types::Scope as _;
use super::*;
use crate::TestWithScope;
#[test]
fn test_owned_scope_methods() {
let mut setup = TestWithScope::new();
let parent_scope = setup.scope();
let (child_ptr, _) = Scope::new(parent_scope, &[]);
let owned_scope = OwnedScope(child_ptr);
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
let val_int = heap.alloc(42);
let val_str = heap.alloc("hello");
let grandchild =
owned_scope.copy_with(vec![("foo", val_int), ("bar", val_str)].into_iter());
assert_eq!(grandchild.get("foo", &heap).unwrap().unpack_i32(), Some(42));
assert_eq!(
grandchild.get("bar", &heap).unwrap().unpack_str(),
Some("hello")
);
assert!(grandchild.get("baz", &heap).is_none());
});
}
}