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

feat: ref

Browse Source
This commit is contained in:
imxyy_soope_
2025-05-11 10:19:55 +08:00
parent cbb29276d8
commit 7cbb082dc4
12 changed files with 180 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/ty/internal/attrset.rs
View File

@@ -12,29 +12,29 @@ use super::super::public as p;
use super::{ToPublic, Value};
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct AttrSet {
data: HashTrieMapSync<Symbol, Value>,
pub struct AttrSet<'vm> {
data: HashTrieMapSync<Symbol, Value<'vm>>,
}
impl AttrSet {
impl<'vm> AttrSet<'vm> {
pub fn empty() -> Self {
AttrSet {
data: HashTrieMapSync::new_sync(),
}
}
pub fn push_attr_force(&mut self, sym: Symbol, val: Value) {
pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
self.data.insert_mut(sym, val);
}
pub fn push_attr(&mut self, sym: Symbol, val: Value) {
pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
if self.data.get_mut(&sym).is_some() {
todo!()
}
self.data.insert_mut(sym, val);
}
pub fn select(&self, sym: Symbol) -> Option<Value> {
pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
self.data.get(&sym).cloned()
}
@@ -42,29 +42,29 @@ impl AttrSet {
self.data.get(&sym).is_some()
}
pub fn update(mut self, other: AttrSet) -> AttrSet {
pub fn update(mut self, other: AttrSet<'vm>) -> AttrSet<'vm> {
for (k, v) in other.data.iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
}
pub fn update_rec(mut self, other: RecAttrSet) -> AttrSet {
pub fn update_rec(mut self, other: RecAttrSet<'vm>) -> AttrSet<'vm> {
for (k, v) in other.data.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
}
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value> {
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
self.data
}
pub fn as_inner(&self) -> &HashTrieMapSync<Symbol, Value> {
pub fn as_inner(&self) -> &HashTrieMapSync<Symbol, Value<'vm>> {
&self.data
}
pub fn force_deep(&mut self, vm: &VM) -> Result<()> {
pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> {
let mut map: Vec<_> = self
.data
.into_iter()
@@ -79,7 +79,7 @@ impl AttrSet {
}
}
impl ToPublic for AttrSet {
impl ToPublic for AttrSet<'_> {
fn to_public(self, vm: &VM) -> p::Value {
p::Value::AttrSet(p::AttrSet::new(
self.data
@@ -91,29 +91,29 @@ impl ToPublic for AttrSet {
}
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct RecAttrSet {
data: Arc<RefCell<HashTrieMapSync<Symbol, Value>>>,
pub struct RecAttrSet<'vm> {
data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
}
impl RecAttrSet {
pub fn empty() -> RecAttrSet {
impl<'vm> RecAttrSet<'vm> {
pub fn empty() -> Self {
RecAttrSet {
data: Arc::default(),
}
}
pub fn push_attr_force(&mut self, sym: Symbol, val: Value) {
pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
self.data.borrow_mut().insert_mut(sym, val);
}
pub fn push_attr(&mut self, sym: Symbol, val: Value) {
pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
if self.data.borrow().get(&sym).is_some() {
todo!()
}
self.data.borrow_mut().insert_mut(sym, val);
}
pub fn select(&self, sym: Symbol) -> Option<Value> {
pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
self.data.borrow().get(&sym).cloned()
}
@@ -121,14 +121,14 @@ impl RecAttrSet {
self.data.borrow().get(&sym).is_some()
}
pub fn update(mut self, other: RecAttrSet) -> RecAttrSet {
pub fn update(mut self, other: RecAttrSet<'vm>) -> RecAttrSet<'vm> {
for (k, v) in other.data.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
}
pub fn update_normal(self, other: AttrSet) -> AttrSet {
pub fn update_normal(self, other: AttrSet<'vm>) -> AttrSet<'vm> {
let map = self
.data
.borrow()
@@ -142,15 +142,15 @@ impl RecAttrSet {
new
}
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value> {
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
self.data.borrow().clone()
}
pub fn from_inner(data: Arc<RefCell<HashTrieMapSync<Symbol, Value>>>) -> Self {
pub fn from_inner(data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>) -> Self {
RecAttrSet { data }
}
pub fn force_deep(&mut self, vm: &VM) -> Result<()> {
pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> {
let mut map: Vec<_> = self
.data
.borrow()
@@ -166,7 +166,7 @@ impl RecAttrSet {
}
}
impl ToPublic for RecAttrSet {
impl ToPublic for RecAttrSet<'_> {
fn to_public(self, vm: &VM) -> p::Value {
p::Value::AttrSet(p::AttrSet::new(
self.data

12
src/ty/internal/func.rs
View File

@@ -41,14 +41,14 @@ impl From<ir::Param> for Param {
}
#[derive(Debug, Clone)]
pub struct Func {
pub env: OnceCell<CapturedEnv>,
pub struct Func<'vm> {
pub env: OnceCell<CapturedEnv<'vm>>,
pub param: Param,
pub opcodes: OpCodes,
}
impl Func {
pub fn call(&self, vm: &VM, arg: Value) -> Result<Value> {
impl<'vm> Func<'vm> {
pub fn call(&'vm self, vm: &VM<'vm>, arg: Value<'vm>) -> Result<Value<'vm>> {
use Param::*;
let env = self.env.get().unwrap().clone().released();
@@ -75,7 +75,7 @@ impl Func {
for (formal, default) in formals {
let arg = arg
.select(formal.clone().into())
.or_else(|| default.map(Value::ThunkRef))
.or_else(|| default.map(|idx| Value::ThunkRef(vm.get_thunk(idx))))
.unwrap();
new.insert_mut(formal.clone().into(), arg);
}
@@ -90,7 +90,7 @@ impl Func {
}
}
impl PartialEq for Func {
impl PartialEq for Func<'_> {
fn eq(&self, _: &Self) -> bool {
false
}

16
src/ty/internal/list.rs
View File

@@ -8,29 +8,29 @@ use crate::vm::VM;
use super::{ToPublic, Value};
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct List {
data: VectorSync<Value>,
pub struct List<'vm> {
data: VectorSync<Value<'vm>>,
}
impl List {
pub fn empty() -> List {
impl<'vm> List<'vm> {
pub fn empty() -> Self {
List {
data: VectorSync::new_sync(),
}
}
pub fn push(&mut self, elem: Value) {
pub fn push(&mut self, elem: Value<'vm>) {
self.data.push_back_mut(elem);
}
pub fn concat(mut self, other: List) -> List {
pub fn concat(mut self, other: List<'vm>) -> List<'vm> {
for elem in other.data.iter() {
self.data.push_back_mut(elem.clone());
}
self
}
pub fn force_deep(&mut self, vm: &VM) -> Result<()> {
pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> {
let mut vec: Vec<_> = self.data.iter().cloned().collect();
vec.iter_mut()
.map(|v| v.force_deep(vm).map(|_| ()))
@@ -41,7 +41,7 @@ impl List {
}
}
impl ToPublic for List {
impl ToPublic for List<'_> {
fn to_public(self, vm: &VM) -> p::Value {
p::Value::List(p::List::new(
self.data

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

@@ -30,20 +30,20 @@ pub trait ToPublic {
}
#[derive(Debug, Clone)]
pub struct Thunk {
pub thunk: RefCell<_Thunk>,
pub env: RefCell<Option<Arc<Env>>>,
pub struct Thunk<'vm> {
pub thunk: RefCell<_Thunk<'vm>>,
pub env: RefCell<Option<Arc<Env<'vm>>>>,
}
#[derive(Debug, IsVariant, Unwrap, Clone)]
pub enum _Thunk {
pub enum _Thunk<'vm> {
Code(OpCodes),
SuspendedFrom(*const Thunk),
Value(Box<Value>),
SuspendedFrom(*const Thunk<'vm>),
Value(Box<Value<'vm>>),
}
impl Thunk {
pub fn new(opcodes: OpCodes) -> Thunk {
impl<'vm> Thunk<'vm> {
pub fn new(opcodes: OpCodes) -> Self {
Thunk {
thunk: RefCell::new(_Thunk::Code(opcodes)),
env: RefCell::new(None),
@@ -54,11 +54,11 @@ impl Thunk {
self.thunk.borrow().clone().unwrap_code()
}
pub fn capture(&self, env: Arc<Env>) {
pub fn capture(&self, env: Arc<Env<'vm>>) {
*self.env.borrow_mut() = Some(env);
}
pub fn force(&self, vm: &VM) -> Result<Value> {
pub fn force(&self, vm: &VM<'vm>) -> Result<Value<'vm>> {
match &*self.thunk.borrow() {
_Thunk::Value(value) => return Ok(value.as_ref().clone()),
_Thunk::SuspendedFrom(from) => {
@@ -82,7 +82,7 @@ impl Thunk {
Ok(value)
}
pub fn value(&self) -> Option<Value> {
pub fn value(&'vm self) -> Option<Value<'vm>> {
match &*self.thunk.borrow() {
_Thunk::Value(value) => Some(value.as_ref().clone()),
_ => None,
@@ -90,62 +90,60 @@ impl Thunk {
}
}
impl PartialEq for Thunk {
impl PartialEq for Thunk<'_> {
fn eq(&self, _: &Self) -> bool {
false
}
}
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
pub enum Value {
pub enum Value<'vm> {
Const(Const),
Thunk(Thunk),
ThunkRef(usize),
AttrSet(AttrSet),
RecAttrSet(RecAttrSet),
List(List),
Thunk(Thunk<'vm>),
ThunkRef(&'vm Thunk<'vm>),
AttrSet(AttrSet<'vm>),
RecAttrSet(RecAttrSet<'vm>),
List(List<'vm>),
Catchable(c::Catchable),
PrimOp(PrimOp),
PartialPrimOp(PartialPrimOp),
Func(usize),
PrimOp(PrimOp<'vm>),
PartialPrimOp(PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
}
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
pub enum ValueAsRef<'v> {
pub enum ValueAsRef<'v, 'vm: 'v> {
Const(&'v Const),
Thunk(&'v Thunk),
ThunkRef(&'v usize),
AttrSet(&'v AttrSet),
RecAttrSet(&'v RecAttrSet),
List(&'v List),
Thunk(&'v Thunk<'vm>),
AttrSet(&'v AttrSet<'vm>),
RecAttrSet(&'v RecAttrSet<'vm>),
List(&'v List<'vm>),
Catchable(&'v c::Catchable),
PrimOp(&'v PrimOp),
PartialPrimOp(&'v PartialPrimOp),
Func(&'v usize),
PrimOp(&'v PrimOp<'vm>),
PartialPrimOp(&'v PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
}
#[derive(Debug, IsVariant, Unwrap, PartialEq)]
pub enum ValueAsMut<'v> {
pub enum ValueAsMut<'v, 'vm: 'v> {
Const(&'v mut Const),
Thunk(&'v Thunk),
ThunkRef(&'v usize),
AttrSet(&'v mut AttrSet),
RecAttrSet(&'v mut RecAttrSet),
List(&'v mut List),
Thunk(&'v Thunk<'vm>),
AttrSet(&'v mut AttrSet<'vm>),
RecAttrSet(&'v mut RecAttrSet<'vm>),
List(&'v mut List<'vm>),
Catchable(&'v mut c::Catchable),
PrimOp(&'v mut PrimOp),
PartialPrimOp(&'v mut PartialPrimOp),
Func(&'v usize),
PrimOp(&'v mut PrimOp<'vm>),
PartialPrimOp(&'v mut PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
}
impl Value {
pub fn as_ref(&self) -> ValueAsRef {
impl<'v, 'vm: 'v> Value<'vm> {
pub fn as_ref(&'vm self) -> ValueAsRef<'v, 'vm> {
use Value::*;
use ValueAsRef as R;
match self {
Const(x) => R::Const(x),
Thunk(x) => R::Thunk(x),
ThunkRef(x) => R::ThunkRef(x),
ThunkRef(x) => R::Thunk(x),
AttrSet(x) => R::AttrSet(x),
RecAttrSet(x) => R::RecAttrSet(x),
List(x) => R::List(x),
@@ -156,13 +154,13 @@ impl Value {
}
}
pub fn as_mut(&mut self) -> ValueAsMut {
pub fn as_mut(&'vm mut self) -> ValueAsMut<'v, 'vm> {
use Value::*;
use ValueAsMut as M;
match self {
Const(x) => M::Const(x),
Thunk(x) => M::Thunk(x),
ThunkRef(x) => M::ThunkRef(x),
ThunkRef(x) => M::Thunk(x),
AttrSet(x) => M::AttrSet(x),
RecAttrSet(x) => M::RecAttrSet(x),
List(x) => M::List(x),
@@ -175,7 +173,7 @@ impl Value {
}
use Value::Const as VmConst;
impl Value {
impl<'vm> Value<'vm> {
pub fn typename(&self) -> &'static str {
use Value::*;
match self {
@@ -200,7 +198,7 @@ impl Value {
}
}
pub fn call(self, vm: &VM, args: Vec<Value>) -> Result<Value> {
pub fn call(self, vm: &VM<'vm>, args: Vec<Value<'vm>>) -> Result<Value<'vm>> {
use Value::*;
Ok(match self {
PrimOp(func) => func.call(vm, args),
@@ -215,7 +213,7 @@ impl Value {
PartialPrimOp(func) => {
return Ok(func.call(vm, [arg].into_iter().chain(iter).collect()));
}
Func(func) => vm.get_func(func).call(vm, arg)?,
Func(func) => func.call(vm, arg)?,
_ => todo!(),
}
}
@@ -226,7 +224,7 @@ impl Value {
})
}
pub fn not(self) -> Value {
pub fn not(self) -> Value<'vm> {
use Const::*;
match self {
VmConst(Bool(bool)) => VmConst(Bool(!bool)),
@@ -235,7 +233,7 @@ impl Value {
}
}
pub fn and(self, other: Value) -> Value {
pub fn and(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
match (self, other) {
(VmConst(Bool(a)), VmConst(Bool(b))) => VmConst(Bool(a && b)),
@@ -244,7 +242,7 @@ impl Value {
}
}
pub fn or(self, other: Value) -> Value {
pub fn or(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
match (self, other) {
(VmConst(Bool(a)), VmConst(Bool(b))) => VmConst(Bool(a || b)),
@@ -253,7 +251,7 @@ impl Value {
}
}
pub fn eq(self, other: Value) -> Value {
pub fn eq(self, other: Value<'vm>) -> Value<'vm> {
use Const::Bool;
match (self, other) {
(x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
@@ -261,7 +259,7 @@ impl Value {
}
}
pub fn lt(self, other: Value) -> Value {
pub fn lt(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
VmConst(Bool(match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => a < b,
@@ -274,7 +272,7 @@ impl Value {
}))
}
pub fn neg(self) -> Value {
pub fn neg(self) -> Value<'vm> {
use Const::*;
match self {
VmConst(Int(int)) => VmConst(Int(-int)),
@@ -284,7 +282,7 @@ impl Value {
}
}
pub fn add(self, other: Value) -> Value {
pub fn add(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a + b)),
@@ -301,7 +299,7 @@ impl Value {
}
}
pub fn mul(self, other: Value) -> Value {
pub fn mul(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a * b)),
@@ -313,7 +311,7 @@ impl Value {
}
}
pub fn div(self, other: Value) -> Value {
pub fn div(self, other: Value<'vm>) -> Value<'vm> {
use Const::*;
match (self, other) {
(_, VmConst(Int(0))) => todo!(),
@@ -327,7 +325,7 @@ impl Value {
}
}
pub fn concat_string(&mut self, mut other: Value) -> &mut Self {
pub fn concat_string(&mut self, mut other: Value<'vm>) -> &mut Self {
match (self.coerce_to_string(), other.coerce_to_string()) {
(VmConst(Const::String(a)), VmConst(Const::String(b))) => a.push_str(b.as_str()),
(_, Value::Catchable(_)) => *self = other,
@@ -337,7 +335,7 @@ impl Value {
self
}
pub fn push(&mut self, elem: Value) -> &mut Self {
pub fn push(&mut self, elem: Value<'vm>) -> &mut Self {
if let Value::List(list) = self {
list.push(elem);
} else if let Value::Catchable(_) = self {
@@ -349,7 +347,7 @@ impl Value {
self
}
pub fn concat(self, other: Value) -> Value {
pub fn concat(self, other: Value<'vm>) -> Value<'vm> {
match (self, other) {
(Value::List(a), Value::List(b)) => Value::List(a.concat(b)),
(x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
@@ -357,7 +355,7 @@ impl Value {
}
}
pub fn push_attr(&mut self, sym: Symbol, val: Value) -> &mut Self {
pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) -> &mut Self {
if let Value::AttrSet(attrs) = self {
attrs.push_attr(sym, val)
} else if let Value::RecAttrSet(attrs) = self {
@@ -371,7 +369,7 @@ impl Value {
self
}
pub fn update(self, other: Value) -> Value {
pub fn update(self, other: Value<'vm>) -> Value<'vm> {
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)),
@@ -399,7 +397,7 @@ impl Value {
Ok(self)
}
pub fn select_with_default(&mut self, sym: Symbol, default: Value) -> Result<&mut Self> {
pub fn select_with_default(&mut self, sym: Symbol, default: Value<'vm>) -> Result<&mut Self> {
let val = match self {
Value::AttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
Value::RecAttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
@@ -438,7 +436,7 @@ impl Value {
self
}
pub fn force(&mut self, vm: &VM) -> Result<&mut Self> {
pub fn force(&mut self, vm: &VM<'vm>) -> Result<&mut Self> {
if let Value::Thunk(thunk) = self {
let value = thunk.force(vm)?;
*self = value
@@ -446,7 +444,7 @@ impl Value {
Ok(self)
}
pub fn force_deep(&mut self, vm: &VM) -> Result<&mut Self> {
pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<&mut Self> {
match self {
Value::Thunk(thunk) => {
let mut value = thunk.force(vm)?;
@@ -462,7 +460,7 @@ impl Value {
}
}
impl ToPublic for Value {
impl ToPublic for Value<'_> {
fn to_public(self, vm: &VM) -> p::Value {
match self {
Value::AttrSet(attrs) => attrs.to_public(vm),

22
src/ty/internal/primop.rs
View File

@@ -5,20 +5,20 @@ use crate::vm::VM;
use super::Value;
#[derive(Debug, Clone, Constructor)]
pub struct PrimOp {
pub struct PrimOp<'vm> {
pub name: &'static str,
arity: u8,
func: fn(&VM, Vec<Value>) -> Value,
func: fn(&VM<'vm>, Vec<Value<'vm>>) -> Value<'vm>,
}
impl PartialEq for PrimOp {
impl PartialEq for PrimOp<'_> {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl PrimOp {
pub fn call(self, vm: &VM, args: Vec<Value>) -> Value {
impl<'vm> PrimOp<'vm> {
pub fn call(self, vm: &VM<'vm>, args: Vec<Value<'vm>>) -> Value<'vm> {
if (args.len() as u8) < self.arity {
Value::PartialPrimOp(PartialPrimOp {
name: self.name,
@@ -35,21 +35,21 @@ impl PrimOp {
}
#[derive(Debug, Clone)]
pub struct PartialPrimOp {
pub struct PartialPrimOp<'vm> {
pub name: &'static str,
arity: u8,
args: Vec<Value>,
func: fn(&VM, Vec<Value>) -> Value,
args: Vec<Value<'vm>>,
func: fn(&VM<'vm>, Vec<Value<'vm>>) -> Value<'vm>,
}
impl PartialEq for PartialPrimOp {
impl PartialEq for PartialPrimOp<'_> {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl PartialPrimOp {
pub fn call(mut self, vm: &VM, args: Vec<Value>) -> Value {
impl<'vm> PartialPrimOp<'vm> {
pub fn call(mut self, vm: &VM<'vm>, args: Vec<Value<'vm>>) -> Value<'vm> {
let len = args.len() as u8;
self.args.extend(args);
if len < self.arity {