maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(tvix/eval): make NixList::clone() cheap

Browse source 
When we start unrecursivifying (sp?) things, Rust's borrow checker
is going to be a headache; its magic only works when you use the CPU
stack as your call stack.

Fixing the borrow checker issues usually involves adding lots of
`clone()`s.  Right now `NixList` is the only variant of `Value` that
isn't cheap to clone() -- all the others are either a wrapper around
Rc or else are of bounded size.

Note that this requires dropping the `DerefMut for NixList` instance
and using `Vec<Value>` instead in those situations.

Change-Id: I5a47df66855342aa2064f8f3cb7934ff422d26bd
Signed-off-by: Adam Joseph <adam@westernsemico.com>
Reviewed-on: https://cl.tvl.fyi/c/depot/+/7359
Reviewed-by: tazjin <tazjin@tvl.su>
Tested-by: BuildkiteCI
This commit is contained in:
Adam Joseph 2022-11-23 00:34:09 -08:00 • committed by clbot
parent c537cc6fce
commit a740653c83
3 changed files with 36 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

25
tvix/eval/src/builtins/mod.rs
View file

@ -360,7 +360,7 @@ mod pure_builtins {
let operator = attrs.select_required("operator")?;
let mut res = NixList::new();
let mut res: Vec<Value> = vec![];
let mut done_keys: Vec<Value> = vec![];
let mut insert_key = |k: Value, vm: &mut VM| -> Result<bool, ErrorKind> {
@ -387,7 +387,7 @@ mod pure_builtins {
work_set.extend(op_result.into_iter());
}
Ok(Value::List(res))
Ok(Value::List(NixList::from(res)))
}
#[builtin("genList")]
@ -415,15 +415,16 @@ mod pure_builtins {
#[builtin("groupBy")]
fn builtin_group_by(vm: &mut VM, f: Value, list: Value) -> Result<Value, ErrorKind> {
let mut res: BTreeMap<NixString, Value> = BTreeMap::new();
let mut res: BTreeMap<NixString, Vec<Value>> = BTreeMap::new();
for val in list.to_list()? {
let key = vm.call_with(&f, [val.clone()])?.force(vm)?.to_str()?;
res.entry(key)
.or_insert_with(|| Value::List(NixList::new()))
.as_list_mut()?
.push(val);
res.entry(key).or_insert_with(|| vec![]).push(val);
}
Ok(Value::attrs(NixAttrs::from_map(res)))
Ok(Value::attrs(NixAttrs::from_map(
res.into_iter()
.map(|(k, v)| (k, Value::List(NixList::from(v))))
.collect(),
)))
}
#[builtin("hasAttr")]
@ -745,7 +746,7 @@ mod pure_builtins {
let re: Regex = Regex::new(re.as_str()).unwrap();
let mut capture_locations = re.capture_locations();
let num_captures = capture_locations.len();
let mut ret = NixList::new();
let mut ret: Vec<Value> = vec![];
let mut pos = 0;
while let Some(thematch) = re.captures_read_at(&mut capture_locations, text, pos) {
@ -770,12 +771,12 @@ mod pure_builtins {
// push the unmatched characters following the last match
ret.push(Value::from(&text[pos..]));
Ok(Value::List(ret))
Ok(Value::List(NixList::from(ret)))
}
#[builtin("sort")]
fn builtin_sort(vm: &mut VM, comparator: Value, list: Value) -> Result<Value, ErrorKind> {
let mut list = list.to_list()?;
let mut list = list.to_list()?.into_vec();
// Used to let errors "escape" from the sorting closure. If anything
// ends up setting an error, it is returned from this function.
@ -806,7 +807,7 @@ mod pure_builtins {
});
match error {
None => Ok(Value::List(list)),
None => Ok(Value::List(NixList::from(list))),
Some(e) => Err(e),
}
}