From c5c3f6c8d462516068c3887735672aa7732d6d06 Mon Sep 17 00:00:00 2001 From: _cry64 Date: Mon, 30 Mar 2026 15:05:20 +1000 Subject: [PATCH] internally pass EvalState via Rc>> --- nixide/src/expr/eval_state.rs | 46 +++++++++++++-------------- nixide/src/expr/eval_state_builder.rs | 24 +++++++------- nixide/src/expr/realised_string.rs | 37 +++++---------------- nixide/src/expr/tests.rs | 15 ++++----- nixide/src/expr/values/attrs.rs | 21 ++++++++---- nixide/src/expr/values/bool.rs | 6 ++-- nixide/src/expr/values/float.rs | 6 ++-- nixide/src/expr/values/function.rs | 14 ++++---- nixide/src/expr/values/int.rs | 6 ++-- nixide/src/expr/values/list.rs | 20 +++++++++--- nixide/src/expr/values/null.rs | 6 ++-- nixide/src/expr/values/path.rs | 6 ++-- nixide/src/expr/values/string.rs | 7 ++-- nixide/src/expr/values/thunk.rs | 12 +++++-- nixide/src/flake/fetchers_settings.rs | 1 - nixide/src/store/mod.rs | 10 +++--- 16 files changed, 127 insertions(+), 110 deletions(-) diff --git a/nixide/src/expr/eval_state.rs b/nixide/src/expr/eval_state.rs index c491642..0103416 100644 --- a/nixide/src/expr/eval_state.rs +++ b/nixide/src/expr/eval_state.rs @@ -1,7 +1,8 @@ -use std::ffi::{CString, c_void}; +use std::cell::RefCell; use std::ptr::NonNull; +use std::rc::Rc; -use crate::errors::new_nixide_error; +use crate::stdext::AsCPtr as _; use super::Value; use crate::errors::ErrorContext; @@ -15,9 +16,9 @@ use crate::{NixideResult, Store}; /// This provides the main interface for evaluating Nix expressions /// and creating values. pub struct EvalState { - inner: NonNull, + inner: Rc>>, - store: Store, + store: Rc>, } // impl Clone for EvalState { @@ -39,31 +40,37 @@ pub struct EvalState { impl AsInnerPtr for EvalState { #[inline] unsafe fn as_ptr(&self) -> *mut sys::EvalState { - self.inner.as_ptr() + self.inner.borrow().as_ptr() } #[inline] unsafe fn as_ref(&self) -> &sys::EvalState { - unsafe { self.inner.as_ref() } + unsafe { self.inner.borrow().as_ref() } } #[inline] unsafe fn as_mut(&mut self) -> &mut sys::EvalState { - unsafe { self.inner.as_mut() } + unsafe { self.inner.borrow_mut().as_mut() } } } impl EvalState { /// Construct a new EvalState directly from its attributes /// - pub(super) fn new(inner: NonNull, store: &Store) -> Self { + pub(super) fn from(inner: NonNull, store: Rc>) -> Self { Self { - inner, - store: store.clone(), + inner: Rc::new(RefCell::new(inner)), + store, } } - pub fn store_ref(&self) -> &Store { + #[inline] + pub fn inner_ref(&self) -> &Rc>> { + &self.inner + } + + #[inline] + pub fn store_ref(&self) -> &Rc> { &self.store } @@ -77,9 +84,10 @@ impl EvalState { /// # Errors /// /// Returns an error if evaluation fails. + /// pub fn interpret(&self, expr: &str, path: &str) -> NixideResult { - let expr_c = CString::new(expr).or(Err(new_nixide_error!(StringNulByte)))?; - let path_c = CString::new(path).or(Err(new_nixide_error!(StringNulByte)))?; + let expr = expr.as_c_ptr()?; + let path = path.as_c_ptr()?; // Allocate value for result // XXX: TODO: create a method for this (``) @@ -90,13 +98,7 @@ impl EvalState { // Evaluate expression wrap::nix_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_expr_eval_from_string( - ctx.as_ptr(), - self.as_ptr(), - expr_c.as_ptr(), - path_c.as_ptr(), - value.as_ptr(), - ); + sys::nix_expr_eval_from_string(ctx.as_ptr(), self.as_ptr(), expr, path, value.as_ptr()); value }) .map(|ptr| Value::from((ptr, self))) @@ -110,7 +112,3 @@ impl Drop for EvalState { } } } - -// SAFETY: EvalState can be shared between threads -unsafe impl Send for EvalState {} -unsafe impl Sync for EvalState {} diff --git a/nixide/src/expr/eval_state_builder.rs b/nixide/src/expr/eval_state_builder.rs index ee3faeb..af4fd7d 100644 --- a/nixide/src/expr/eval_state_builder.rs +++ b/nixide/src/expr/eval_state_builder.rs @@ -1,5 +1,7 @@ -use std::ffi::{CString, c_char, c_void}; +use std::cell::RefCell; +use std::ffi::{CString, c_char}; use std::ptr::{self, NonNull}; +use std::rc::Rc; use super::EvalState; #[cfg(feature = "flakes")] @@ -16,8 +18,8 @@ use crate::util::{panic_issue_call_failed, wrap}; /// the evaluation state. /// pub struct EvalStateBuilder { - inner: NonNull, - store: Store, + inner: Rc>>, + store: Rc>, } // impl Clone for EvalStateBuilder { @@ -39,17 +41,17 @@ pub struct EvalStateBuilder { impl AsInnerPtr for EvalStateBuilder { #[inline] unsafe fn as_ptr(&self) -> *mut sys::nix_eval_state_builder { - self.inner.as_ptr() + self.inner.borrow().as_ptr() } #[inline] unsafe fn as_ref(&self) -> &sys::nix_eval_state_builder { - unsafe { self.inner.as_ref() } + unsafe { self.inner.borrow().as_ref() } } #[inline] unsafe fn as_mut(&mut self) -> &mut sys::nix_eval_state_builder { - unsafe { self.inner.as_mut() } + unsafe { self.inner.borrow_mut().as_mut() } } } @@ -64,14 +66,14 @@ impl EvalStateBuilder { /// /// Returns an error if the builder cannot be created. /// - pub fn new(store: &Store) -> NixideResult { + pub fn new(store: Rc>) -> NixideResult { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_eval_state_builder_new(ctx.as_ptr(), store.as_ptr()) + sys::nix_eval_state_builder_new(ctx.as_ptr(), store.borrow().as_ptr()) })?; Ok(EvalStateBuilder { - inner, - store: store.clone(), + inner: Rc::new(RefCell::new(inner)), + store, }) } @@ -87,7 +89,7 @@ impl EvalStateBuilder { sys::nix_eval_state_build(ctx.as_ptr(), self.as_ptr()) })?; - Ok(EvalState::new(inner, &self.store)) + Ok(EvalState::from(inner, self.store.clone())) } // XXX: TODO: use `flakes()` instead diff --git a/nixide/src/expr/realised_string.rs b/nixide/src/expr/realised_string.rs index 5d5e08f..0d41b6f 100644 --- a/nixide/src/expr/realised_string.rs +++ b/nixide/src/expr/realised_string.rs @@ -1,15 +1,15 @@ use std::cell::RefCell; -use std::ffi::{c_char, c_void}; +use std::ffi::c_char; use std::ptr::NonNull; use crate::errors::ErrorContext; use crate::expr::values::NixString; use crate::stdext::CCharPtrExt; -use crate::sys; use crate::util::LazyArray; use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; use crate::{EvalState, NixideResult, StorePath}; +use crate::{Store, sys}; pub struct RealisedString<'a> { inner: RefCell>, @@ -17,23 +17,6 @@ pub struct RealisedString<'a> { pub children: LazyArray StorePath + 'a>>, } -// impl<'a> Clone for RealisedString<'a> { -// fn clone(&self) -> Self { -// let inner = self.inner.clone(); - -// wrap::nix_fn!(|ctx: &ErrorContext| unsafe { -// sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void); -// }) -// .unwrap(); - -// Self { -// inner, -// path: self.path.clone(), -// children: self.children, -// } -// } -// } - impl<'a> AsInnerPtr for RealisedString<'a> { #[inline] unsafe fn as_ptr(&self) -> *mut sys::nix_realised_string { @@ -63,7 +46,7 @@ impl<'a> RealisedString<'a> { /// Realise a string context. /// /// This will - /// - realise the store paths referenced by the string's context, and + /// - realise the store paths referenced by the string's content, and /// - perform the replacement of placeholders. /// - create temporary garbage collection roots for the store paths, for /// the lifetime of the current process. @@ -77,9 +60,6 @@ impl<'a> RealisedString<'a> { /// You should set this to true when this call is part of a primop. /// You should set this to false when building for your application's purpose. /// - /// # Returns - /// - /// NULL if failed, or a new nix_realised_string, which must be freed with nix_realised_string_free pub fn new(value: &NixString, state: &'a EvalState) -> NixideResult> { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { sys::nix_string_realise( @@ -89,21 +69,20 @@ impl<'a> RealisedString<'a> { false, // don't copy more ) })?; - let cell = RefCell::new(inner); let size = unsafe { sys::nix_realised_string_get_store_path_count(inner.as_ptr()) }; Ok(Self { - inner: cell, - path: Self::parse_path(inner.as_ptr(), state), + inner: RefCell::new(inner), + path: Self::parse_path(inner.as_ptr(), &state.store_ref().borrow()), children: LazyArray::new( size, - Box::new(|_| StorePath::fake_path(state.store_ref()).unwrap()), + Box::new(|_| StorePath::fake_path(&state.store_ref().borrow()).unwrap()), ), }) } - fn parse_path(realised_string: *mut sys::nix_realised_string, state: &EvalState) -> StorePath { + fn parse_path(realised_string: *mut sys::nix_realised_string, store: &Store) -> StorePath { let buffer_ptr = unsafe { sys::nix_realised_string_get_buffer_start(realised_string) }; let buffer_size = unsafe { sys::nix_realised_string_get_buffer_size(realised_string) }; @@ -115,7 +94,7 @@ impl<'a> RealisedString<'a> { err ) }); - StorePath::parse(state.store_ref(), &path_str).unwrap_or_else(|err| { + StorePath::parse(store, &path_str).unwrap_or_else(|err| { panic_issue_call_failed!( "`sys::nix_realised_string_get_buffer_(start|size)` invalid store path ({})", err diff --git a/nixide/src/expr/tests.rs b/nixide/src/expr/tests.rs index 5233ea2..e9342d0 100644 --- a/nixide/src/expr/tests.rs +++ b/nixide/src/expr/tests.rs @@ -1,5 +1,3 @@ -use std::rc::Rc; - use serial_test::serial; use super::{EvalStateBuilder, Value}; @@ -8,19 +6,18 @@ use crate::Store; #[test] #[serial] fn test_eval_state_builder() { - let store = Rc::new(Store::default().expect("Failed to open store")); - let _state = EvalStateBuilder::new(&store) + let store = Store::default().expect("Failed to open store"); + let _state = EvalStateBuilder::new(store.clone()) .expect("Failed to create builder") .build() .expect("Failed to build state"); - // State should be dropped automatically } #[test] #[serial] fn test_simple_evaluation() { - let store = Rc::new(Store::default().expect("Failed to open store")); - let state = EvalStateBuilder::new(&store) + let store = Store::default().expect("Failed to open store"); + let state = EvalStateBuilder::new(store.clone()) .expect("Failed to create builder") .build() .expect("Failed to build state"); @@ -41,7 +38,7 @@ fn test_simple_evaluation() { #[serial] fn test_value_types() { let store = Store::default().expect("Failed to open store"); - let state = EvalStateBuilder::new(&store) + let state = EvalStateBuilder::new(store.clone()) .expect("Failed to create builder") .build() .expect("Failed to build state"); @@ -84,7 +81,7 @@ fn test_value_types() { #[serial] fn test_value_formatting() { let store = Store::default().expect("Failed to open store"); - let state = EvalStateBuilder::new(&store) + let state = EvalStateBuilder::new(store.clone()) .expect("Failed to create builder") .build() .expect("Failed to build state"); diff --git a/nixide/src/expr/values/attrs.rs b/nixide/src/expr/values/attrs.rs index 9f8f8e4..4a3c2dd 100644 --- a/nixide/src/expr/values/attrs.rs +++ b/nixide/src/expr/values/attrs.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::{self, NonNull}; +use std::rc::Rc; use super::{NixThunk, NixValue, Value}; use crate::errors::{ErrorContext, NixideError}; @@ -11,7 +13,7 @@ use crate::{EvalState, NixError}; pub struct NixAttrs { inner: NonNull, - state: EvalState, + state: Rc>>, len: u32, } @@ -84,7 +86,7 @@ impl NixValue for NixAttrs { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), len, } } @@ -107,7 +109,7 @@ impl NixAttrs { sys::nix_get_attr_byidx( ctx.as_ptr(), self.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), index, name_ptr, ) @@ -134,7 +136,7 @@ impl NixAttrs { sys::nix_get_attr_byidx_lazy( ctx.as_ptr(), self.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), index, name_ptr, ) @@ -156,7 +158,12 @@ impl NixAttrs { } let name_ptr = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_get_attr_name_byidx(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index) + sys::nix_get_attr_name_byidx( + ctx.as_ptr(), + self.as_ptr(), + self.state.borrow().as_ptr(), + index, + ) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); @@ -175,7 +182,7 @@ impl NixAttrs { sys::nix_get_attr_byname( ctx.as_ptr(), self.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), name.as_ref() .into_c_ptr() .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)), @@ -201,7 +208,7 @@ impl NixAttrs { sys::nix_get_attr_byname_lazy( ctx.as_ptr(), self.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), name.as_ref() .into_c_ptr() .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)), diff --git a/nixide/src/expr/values/bool.rs b/nixide/src/expr/values/bool.rs index dd04031..0fdb0d8 100644 --- a/nixide/src/expr/values/bool.rs +++ b/nixide/src/expr/values/bool.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::errors::ErrorContext; @@ -10,7 +12,7 @@ use crate::{EvalState, sys}; pub struct NixBool { inner: NonNull, - state: EvalState, + state: Rc>>, value: bool, } @@ -85,7 +87,7 @@ impl NixValue for NixBool { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), value, } } diff --git a/nixide/src/expr/values/float.rs b/nixide/src/expr/values/float.rs index 9538b45..54b6e11 100644 --- a/nixide/src/expr/values/float.rs +++ b/nixide/src/expr/values/float.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::EvalState; @@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap}; pub struct NixFloat { inner: NonNull, - state: EvalState, + state: Rc>>, value: f64, } @@ -85,7 +87,7 @@ impl NixValue for NixFloat { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), value, } } diff --git a/nixide/src/expr/values/function.rs b/nixide/src/expr/values/function.rs index 83d7d2a..cbf676e 100644 --- a/nixide/src/expr/values/function.rs +++ b/nixide/src/expr/values/function.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::{NixValue, Value}; use crate::errors::ErrorContext; @@ -10,7 +12,7 @@ use crate::{EvalState, sys}; pub struct NixFunction { inner: NonNull, - state: EvalState, + state: Rc>>, } impl Clone for NixFunction { @@ -76,7 +78,7 @@ impl NixValue for NixFunction { fn from(inner: NonNull, state: &EvalState) -> Self { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), } } } @@ -87,14 +89,14 @@ impl NixFunction { T: NixValue, { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_alloc_value(ctx.as_ptr(), self.state.as_ptr()) + sys::nix_alloc_value(ctx.as_ptr(), self.state.borrow().as_ptr()) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_value_call( ctx.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), self.as_ptr(), arg.as_ptr(), inner.as_ptr(), @@ -110,14 +112,14 @@ impl NixFunction { T: NixValue, { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_alloc_value(ctx.as_ptr(), self.state.as_ptr()) + sys::nix_alloc_value(ctx.as_ptr(), self.state.borrow().as_ptr()) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_value_call_multi( ctx.as_ptr(), - self.state.as_ptr(), + self.state.borrow().as_ptr(), self.as_ptr(), args.len(), args.into_c_array(), diff --git a/nixide/src/expr/values/int.rs b/nixide/src/expr/values/int.rs index 86e5e94..7d7fe03 100644 --- a/nixide/src/expr/values/int.rs +++ b/nixide/src/expr/values/int.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::EvalState; @@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap}; pub struct NixInt { inner: NonNull, - state: EvalState, + state: Rc>>, value: i64, } @@ -83,7 +85,7 @@ impl NixValue for NixInt { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), value, } } diff --git a/nixide/src/expr/values/list.rs b/nixide/src/expr/values/list.rs index 4c0f354..4d0264f 100644 --- a/nixide/src/expr/values/list.rs +++ b/nixide/src/expr/values/list.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::{NixThunk, NixValue, Value}; use crate::EvalState; @@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap}; pub struct NixList { inner: NonNull, - state: EvalState, + state: Rc>>, } impl Clone for NixList { @@ -76,7 +78,7 @@ impl NixValue for NixList { fn from(inner: NonNull, state: &EvalState) -> Self { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), } } } @@ -116,7 +118,12 @@ impl NixList { pub fn get(&self, index: u32) -> Value { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_get_list_byidx(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index) + sys::nix_get_list_byidx( + ctx.as_ptr(), + self.as_ptr(), + self.state.borrow().as_ptr(), + index, + ) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); @@ -125,7 +132,12 @@ impl NixList { pub fn get_lazy(&self, index: u32) -> NixThunk { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_get_list_byidx_lazy(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index) + sys::nix_get_list_byidx_lazy( + ctx.as_ptr(), + self.as_ptr(), + self.state.borrow().as_ptr(), + index, + ) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); diff --git a/nixide/src/expr/values/null.rs b/nixide/src/expr/values/null.rs index fd20445..bccbe70 100644 --- a/nixide/src/expr/values/null.rs +++ b/nixide/src/expr/values/null.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::EvalState; @@ -10,7 +12,7 @@ use crate::util::wrappers::AsInnerPtr; pub struct NixNull { inner: NonNull, - state: EvalState, + state: Rc>>, } impl Clone for NixNull { @@ -76,7 +78,7 @@ impl NixValue for NixNull { fn from(inner: NonNull, state: &EvalState) -> Self { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), } } } diff --git a/nixide/src/expr/values/path.rs b/nixide/src/expr/values/path.rs index 6d51fd6..0ba968c 100644 --- a/nixide/src/expr/values/path.rs +++ b/nixide/src/expr/values/path.rs @@ -1,6 +1,8 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::path::PathBuf; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::errors::ErrorContext; @@ -12,7 +14,7 @@ use crate::{EvalState, sys}; pub struct NixPath { inner: NonNull, - state: EvalState, + state: Rc>>, value: PathBuf, } @@ -87,7 +89,7 @@ impl NixValue for NixPath { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), value, } } diff --git a/nixide/src/expr/values/string.rs b/nixide/src/expr/values/string.rs index 765d763..20864b9 100644 --- a/nixide/src/expr/values/string.rs +++ b/nixide/src/expr/values/string.rs @@ -1,5 +1,8 @@ +use std::cell::RefCell; +use std::ffi::c_void; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::NixValue; use crate::errors::ErrorContext; @@ -10,7 +13,7 @@ use crate::{EvalState, sys}; pub struct NixString { inner: NonNull, - state: EvalState, + state: Rc>>, value: String, } @@ -90,7 +93,7 @@ impl NixValue for NixString { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), value, } } diff --git a/nixide/src/expr/values/thunk.rs b/nixide/src/expr/values/thunk.rs index b6439ce..c7f0cb3 100644 --- a/nixide/src/expr/values/thunk.rs +++ b/nixide/src/expr/values/thunk.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use std::ptr::NonNull; +use std::rc::Rc; use super::{NixValue, Value}; use crate::EvalState; @@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap}; pub struct NixThunk { inner: NonNull, - state: EvalState, + state: Rc>>, } impl Clone for NixThunk { @@ -76,7 +78,7 @@ impl NixValue for NixThunk { fn from(inner: NonNull, state: &EvalState) -> Self { Self { inner, - state: state.clone(), + state: state.inner_ref().clone(), } } } @@ -84,7 +86,11 @@ impl NixValue for NixThunk { impl NixThunk { pub fn eval(self) -> Value { wrap::nix_fn!(|ctx: &ErrorContext| unsafe { - sys::nix_value_force(ctx.as_ptr(), self.state.as_ptr(), self.inner.as_ptr()) + sys::nix_value_force( + ctx.as_ptr(), + self.state.borrow().as_ptr(), + self.inner.as_ptr(), + ) }) .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)); diff --git a/nixide/src/flake/fetchers_settings.rs b/nixide/src/flake/fetchers_settings.rs index 1f24d04..cf15df2 100644 --- a/nixide/src/flake/fetchers_settings.rs +++ b/nixide/src/flake/fetchers_settings.rs @@ -1,4 +1,3 @@ -use std::ffi::c_void; use std::ptr::NonNull; use crate::NixideResult; diff --git a/nixide/src/store/mod.rs b/nixide/src/store/mod.rs index 35c04e8..f40a395 100644 --- a/nixide/src/store/mod.rs +++ b/nixide/src/store/mod.rs @@ -7,9 +7,11 @@ mod tests; mod path; pub use path::*; +use std::cell::RefCell; use std::ffi::{c_char, c_void}; use std::path::PathBuf; use std::ptr::{NonNull, null, null_mut}; +use std::rc::Rc; use crate::NixideResult; use crate::errors::ErrorContext; @@ -68,24 +70,24 @@ impl Store { /// /// Returns an error if the store cannot be opened. /// - pub fn open(uri: &str) -> NixideResult { + pub fn open(uri: &str) -> NixideResult>> { Self::open_ptr(uri.as_c_ptr()?) } /// Opens a connection to the default Nix store. /// - pub fn default() -> NixideResult { + pub fn default() -> NixideResult>> { Self::open_ptr(null()) } #[inline] - fn open_ptr(uri_ptr: *const c_char) -> NixideResult { + fn open_ptr(uri_ptr: *const c_char) -> NixideResult>> { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { // XXX: TODO: allow args to be parsed instead of just `null_mut` sys::nix_store_open(ctx.as_ptr(), uri_ptr, null_mut()) })?; - Ok(Store { inner }) + Ok(Rc::new(RefCell::new(Store { inner }))) } /// Realize a store path.