blob: dd970e459dd206c2dae3ae803091bd26781f46d8 [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::{list::ListRef, structs::StructRef};
use crate::{
bridge::{SliceAny, Value, ValueType},
Immutable, Scope, Slice,
};
impl Value {
fn list_value(&self) -> Immutable<Slice<Self>> {
Immutable::from(Slice::from(crate::bridge::list_value_cxx(self)))
}
pub fn to_rust<'v>(&self, heap: &starlark::values::Heap<'v>) -> starlark::values::Value<'v> {
match self.kind() {
ValueType::None => starlark::values::Value::new_none(),
ValueType::Boolean => starlark::values::Value::new_bool(*self.boolean_value()),
ValueType::Integer => heap.alloc(*self.int_value()),
ValueType::String => heap.alloc(self.string_value()),
ValueType::List => {
let slice = self.list_value();
let items: Vec<_> = slice.iter().map(|item| item.to_rust(heap)).collect();
heap.alloc(items)
},
ValueType::Scope => {
let scope_ptr = self.scope_value();
// Safety: C++ Value invariants guarantee that scope_value() is never null
// when the type is SCOPE.
let scope = unsafe { &*scope_ptr };
heap.alloc(starlark::values::structs::AllocStruct(scope.get_kv(heap)))
},
_ => unreachable!(),
}
}
pub fn assign<'v>(
mut self: Pin<&mut Self>,
val: starlark::values::Value<'v>,
scope: &mut Scope,
origin: crate::bridge::ParseNodePtr,
) {
if val.is_none() {
crate::bridge::SetValueNone(self.as_mut(), origin);
} else if let Some(s) = val.unpack_str() {
crate::bridge::SetValueString(self.as_mut(), origin, s);
} else if let Some(b) = val.unpack_bool() {
crate::bridge::SetValueBool(self.as_mut(), origin, b);
} else if let Some(i) = val.unpack_i32() {
crate::bridge::SetValueInt(self.as_mut(), origin, i64::from(i));
} else if let Some(l) = ListRef::from_value(val) {
let mut slice: Slice<Self> = SliceAny {
ptr: crate::bridge::SetValueList(self.as_mut(), origin, l.len()),
len: l.len(),
}
.into();
for (el_pin, src) in slice.iter_mut().zip(l.iter()) {
el_pin.assign(src, scope, origin);
}
} else if let Some(s) = StructRef::from_value(val) {
let keys: Vec<&str> = s.iter().map(|(k, _)| k.as_str()).collect();
let (nested_scope, mut values) = Scope::new(scope, &keys);
for (v_starlark, v_cxx) in s.iter().map(|(_, v)| v).zip(values.as_slice_mut()) {
v_cxx.as_mut().assign(v_starlark, scope, origin);
}
crate::bridge::SetValueScope(self.as_mut(), origin, nested_scope);
} else {
todo!("Arbitrary starlark values not (yet) supported");
}
}
}
#[cfg(test)]
mod tests {
use starlark::values::{FrozenValue, Heap, ValueLike as _};
use super::*;
use crate::TestWithScope;
fn back_and_forth<'v>(
heap: &Heap<'v>,
val: starlark::values::Value<'v>,
) -> starlark::values::Value<'v> {
let mut setup = TestWithScope::new();
let scope = setup.scope();
let mut value = crate::bridge::NewValueForTesting();
value.pin_mut().assign(
val,
scope,
crate::bridge::ParseNodePtr {
ptr: std::ptr::null(),
},
);
value.to_rust(heap)
}
#[test]
fn test_none_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
assert!(back_and_forth(&heap, FrozenValue::new_none().to_value()).is_none());
});
}
#[test]
fn test_bool_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
assert_eq!(
back_and_forth(&heap, heap.alloc(true).to_value()).unpack_bool(),
Some(true)
);
assert_eq!(
back_and_forth(&heap, heap.alloc(false).to_value()).unpack_bool(),
Some(false)
);
});
}
#[test]
fn test_int_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
assert_eq!(
back_and_forth(&heap, heap.alloc(123456789i32).to_value()).unpack_i32(),
Some(123456789)
);
});
}
#[test]
fn test_string_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
assert_eq!(
back_and_forth(&heap, heap.alloc("hello world").to_value()).unpack_str(),
Some("hello world")
);
assert_eq!(
back_and_forth(
&heap,
heap.alloc("hello long string without SSO optimizations")
.to_value(),
)
.unpack_str(),
Some("hello long string without SSO optimizations")
);
});
}
#[test]
fn test_list_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
let list_ref = ListRef::from_value(back_and_forth(
&heap,
heap.alloc(vec![heap.alloc(42), heap.alloc("hello")])
.to_value(),
))
.unwrap();
assert_eq!(list_ref.len(), 2);
let mut iter = list_ref.iter();
assert_eq!(iter.next().unwrap().unpack_i32(), Some(42));
assert_eq!(iter.next().unwrap().unpack_str(), Some("hello"));
});
}
#[test]
fn test_struct_conversion() {
starlark::environment::Module::with_temp_heap(|module| {
let heap = module.heap();
let struct_ref = StructRef::from_value(back_and_forth(
&heap,
heap.alloc(starlark::values::structs::AllocStruct(vec![
("foo", heap.alloc(100)),
("bar", heap.alloc("baz")),
]))
.to_value(),
))
.unwrap();
let get_field = |name: &str| {
struct_ref
.iter()
.find(|(k, _)| k.as_str() == name)
.map(|(_, v)| v)
};
assert_eq!(get_field("foo").unwrap().unpack_i32(), Some(100));
assert_eq!(get_field("bar").unwrap().unpack_str(), Some("baz"));
});
}
}