imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

feat(value): less clone

Browse Source
This commit is contained in:
imxyy_soope_
2025-05-17 15:18:16 +08:00
parent 85f06a30cd
commit 8480e0891b
10 changed files with 154 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/ty/internal/mod.rs
View File

@@ -1,5 +1,7 @@
use std::cell::OnceCell;
use std::cell::RefCell;
use std::collections::HashSet;
use std::hash::Hash;
use std::rc::Rc;
use derive_more::{IsVariant, Unwrap};
@@ -27,17 +29,37 @@ pub use primop::*;
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
pub enum Value<'vm> {
Const(Const),
Thunk(Thunk<'vm>),
Thunk(Rc<Thunk<'vm>>),
ThunkRef(&'vm Thunk<'vm>),
AttrSet(AttrSet<'vm>),
RecAttrSet(RecAttrSet<'vm>),
List(List<'vm>),
AttrSet(Rc<AttrSet<'vm>>),
RecAttrSet(Rc<RecAttrSet<'vm>>),
List(Rc<List<'vm>>),
Catchable(c::Catchable),
PrimOp(PrimOp<'vm>),
PartialPrimOp(PartialPrimOp<'vm>),
Func(Func<'vm>),
PrimOp(Rc<PrimOp<'vm>>),
PartialPrimOp(Rc<PartialPrimOp<'vm>>),
Func(Rc<Func<'vm>>),
}
impl Hash for Value<'_> {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
use Value::*;
match self {
Const(x) => x.hash(state),
Thunk(x) => (x.as_ref() as *const self::Thunk).hash(state),
ThunkRef(x) => (*x as *const self::Thunk).hash(state),
AttrSet(x) => (x.as_ref() as *const self::AttrSet).hash(state),
RecAttrSet(x) => (x.as_ref() as *const self::RecAttrSet).hash(state),
List(x) => (x.as_ref() as *const self::List).hash(state),
Catchable(x) => x.hash(state),
PrimOp(x) => (x.as_ref() as *const self::PrimOp).hash(state),
PartialPrimOp(x) => (x.as_ref() as *const self::PartialPrimOp).hash(state),
Func(x) => (x.as_ref() as *const self::Func).hash(state),
}
}
}
impl Eq for Value<'_> {}
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
pub enum ValueAsRef<'v, 'vm: 'v> {
Const(&'v Const),
@@ -89,12 +111,12 @@ impl<'v, 'vm: 'v> Value<'vm> {
Const(x) => M::Const(x),
Thunk(x) => M::Thunk(x),
ThunkRef(x) => M::Thunk(x),
AttrSet(x) => M::AttrSet(x),
RecAttrSet(x) => M::RecAttrSet(x),
List(x) => M::List(x),
AttrSet(x) => M::AttrSet(Rc::make_mut(x)),
RecAttrSet(x) => M::RecAttrSet(Rc::make_mut(x)),
List(x) => M::List(Rc::make_mut(x)),
Catchable(x) => M::Catchable(x),
PrimOp(x) => M::PrimOp(x),
PartialPrimOp(x) => M::PartialPrimOp(x),
PrimOp(x) => M::PrimOp(Rc::make_mut(x)),
PartialPrimOp(x) => M::PartialPrimOp(Rc::make_mut(x)),
Func(x) => M::Func(x),
}
}
@@ -130,13 +152,14 @@ impl<'vm> Value<'vm> {
}
}
pub fn call(self, vm: &'vm VM<'_>, args: Vec<Self>) -> Result<Self> {
pub fn call(&self, vm: &'vm VM<'_>, args: Vec<Self>) -> Result<Self> {
use Value::*;
match self {
PrimOp(func) => func.call(vm, args),
PartialPrimOp(func) => func.call(vm, args),
mut func @ Value::Func(_) => {
func @ Value::Func(_) => {
let mut iter = args.into_iter();
let mut func = func.clone();
while let Some(arg) = iter.next() {
func = match func {
PrimOp(func) => {
@@ -151,7 +174,7 @@ impl<'vm> Value<'vm> {
}
func.ok()
}
x @ Catchable(_) => x.ok(),
x @ Catchable(_) => x.clone().ok(),
_ => todo!(),
}
}
@@ -247,7 +270,10 @@ impl<'vm> Value<'vm> {
use Const::*;
Ok(match (self, other) {
(_, VmConst(Int(0))) => return Err(Error::EvalError("division by zero".to_string())),
(_, VmConst(Float(0.))) => return Err(Error::EvalError("division by zero".to_string())), (VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a / b)),
(_, VmConst(Float(0.))) => {
return Err(Error::EvalError("division by zero".to_string()));
}
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a / b)),
(VmConst(Int(a)), VmConst(Float(b))) => VmConst(Float(a as f64 / b)),
(VmConst(Float(a)), VmConst(Int(b))) => VmConst(Float(a / b as f64)),
(VmConst(Float(a)), VmConst(Float(b))) => VmConst(Float(a / b)),
@@ -268,7 +294,7 @@ impl<'vm> Value<'vm> {
pub fn push(&mut self, elem: Self) -> &mut Self {
if let Value::List(list) = self {
list.push(elem);
Rc::make_mut(list).push(elem);
} else if let Value::Catchable(_) = self {
} else if let Value::Catchable(_) = elem {
*self = elem;
@@ -280,7 +306,10 @@ impl<'vm> Value<'vm> {
pub fn concat(self, other: Self) -> Self {
match (self, other) {
(Value::List(a), Value::List(b)) => Value::List(a.concat(b)),
(Value::List(mut a), Value::List(b)) => {
Rc::make_mut(&mut a).concat(b.as_ref());
Value::List(a)
}
(x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
_ => todo!(),
}
@@ -288,9 +317,9 @@ impl<'vm> Value<'vm> {
pub fn push_attr(&mut self, sym: usize, val: Self) -> &mut Self {
if let Value::AttrSet(attrs) = self {
attrs.push_attr(sym, val)
Rc::make_mut(attrs).push_attr(sym, val)
} else if let Value::RecAttrSet(attrs) = self {
attrs.push_attr(sym, val)
Rc::make_mut(attrs).push_attr(sym, val)
} else if let Value::Catchable(_) = self {
} else if let Value::Catchable(_) = val {
*self = val
@@ -302,22 +331,30 @@ impl<'vm> Value<'vm> {
pub fn update(self, other: Self) -> Self {
match (self, other) {
(Value::AttrSet(a), Value::AttrSet(b)) => Value::AttrSet(a.update(b)),
(Value::RecAttrSet(a), Value::AttrSet(b)) => Value::AttrSet(a.update_normal(b)),
(Value::AttrSet(a), Value::RecAttrSet(b)) => Value::AttrSet(a.update_rec(b)),
(Value::AttrSet(mut a), Value::AttrSet(b)) => {
Rc::make_mut(&mut a).update(b.as_ref());
Value::AttrSet(a)
}
(Value::RecAttrSet(a), Value::AttrSet(b)) => {
Value::AttrSet(a.update_normal(b.as_ref()).into())
}
(Value::AttrSet(mut a), Value::RecAttrSet(b)) => {
Rc::make_mut(&mut a).update_rec(b.as_ref());
Value::AttrSet(a)
}
(x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
_ => todo!(),
}
}
pub fn select(&mut self, sym: usize) -> Result<&mut Self> {
pub fn select(&mut self, sym: usize, vm: &'vm VM<'_>) -> Result<&mut Self> {
let val = match self {
Value::AttrSet(attrs) => attrs
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
.ok_or_else(|| Error::EvalError(format!("{} not found", vm.get_sym(sym)))),
Value::RecAttrSet(attrs) => attrs
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
.ok_or_else(|| Error::EvalError(format!("{} not found", vm.get_sym(sym)))),
Value::Catchable(_) => return Ok(self),
_ => Err(Error::EvalError(format!(
"cannot select from {:?}",
@@ -390,23 +427,25 @@ impl<'vm> Value<'vm> {
let _ = value.force_deep(vm)?;
*self = value;
}
Value::List(list) => list.force_deep(vm)?,
Value::AttrSet(attrs) => attrs.force_deep(vm)?,
Value::RecAttrSet(attrs) => attrs.force_deep(vm)?,
Value::List(list) => Rc::make_mut(list).force_deep(vm)?,
Value::AttrSet(attrs) => Rc::make_mut(attrs).force_deep(vm)?,
Value::RecAttrSet(attrs) => Rc::make_mut(attrs).force_deep(vm)?,
_ => (),
}
Ok(self)
}
}
impl ToPublic for Value<'_> {
fn to_public(self, vm: &VM) -> p::Value {
pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'vm>>) -> p::Value {
if seen.contains(self) {
return p::Value::Repeated;
}
seen.insert(self.clone());
match self {
Value::AttrSet(attrs) => attrs.to_public(vm),
Value::RecAttrSet(attrs) => attrs.to_public(vm),
Value::List(list) => list.to_public(vm),
Value::Catchable(catchable) => p::Value::Catchable(catchable),
Value::Const(cnst) => p::Value::Const(cnst.into()),
Value::AttrSet(attrs) => attrs.to_public(vm, seen),
Value::RecAttrSet(attrs) => attrs.to_public(vm, seen),
Value::List(list) => list.to_public(vm, seen),
Value::Catchable(catchable) => p::Value::Catchable(catchable.clone()),
Value::Const(cnst) => p::Value::Const(cnst.clone().into()),
Value::Thunk(_) => p::Value::Thunk,
Value::ThunkRef(_) => p::Value::Thunk,
Value::PrimOp(primop) => p::Value::PrimOp(primop.name),
@@ -416,26 +455,22 @@ impl ToPublic for Value<'_> {
}
}
pub trait ToPublic {
fn to_public(self, vm: &VM) -> p::Value;
}
#[derive(Debug, Clone)]
pub struct Thunk<'vm> {
pub thunk: Rc<RefCell<_Thunk<'vm>>>,
pub thunk: RefCell<_Thunk<'vm>>,
}
#[derive(Debug, IsVariant, Unwrap, Clone)]
pub enum _Thunk<'vm> {
Code(&'vm OpCodes, OnceCell<Rc<Env<'vm>>>),
SuspendedFrom(*const Thunk<'vm>),
Value(Box<Value<'vm>>),
Value(Value<'vm>),
}
impl<'vm> Thunk<'vm> {
pub fn new(opcodes: &'vm OpCodes) -> Self {
Thunk {
thunk: Rc::new(RefCell::new(_Thunk::Code(opcodes, OnceCell::new()))),
thunk: RefCell::new(_Thunk::Code(opcodes, OnceCell::new())),
}
}
@@ -447,7 +482,7 @@ impl<'vm> Thunk<'vm> {
pub fn force(&self, vm: &'vm VM<'_>) -> Result<Value<'vm>> {
match &*self.thunk.borrow() {
_Thunk::Value(value) => return Ok(value.as_ref().clone()),
_Thunk::Value(value) => return Ok(value.clone()),
_Thunk::SuspendedFrom(from) => {
return Err(Error::EvalError(format!(
"thunk {:p} already suspended from {from:p} (infinite recursion encountered)",
@@ -471,7 +506,7 @@ impl<'vm> Thunk<'vm> {
pub fn value(&'vm self) -> Option<Value<'vm>> {
match &*self.thunk.borrow() {
_Thunk::Value(value) => Some(value.as_ref().clone()),
_Thunk::Value(value) => Some(value.clone()),
_ => None,
}
}