1use std::borrow::Cow;2use std::cell::RefCell;3use std::ffi::{CStr, CString, c_char, c_int, c_uint, c_void};4use std::fmt;5use std::ptr::null_mut;6use std::sync::LazyLock;7use std::{collections::HashMap, path::PathBuf};89use anyhow::{Context, anyhow, bail};10use serde::Serialize;11use serde::de::DeserializeOwned;1213pub use anyhow::Result;1415use self::logging::nix_logging_cxx;16use self::nix_cxx::set_fetcher_setting;17use self::nix_raw::{18 alloc_value, c_context, c_context_create, err_code, err_info_msg, eval_state_build,19 eval_state_builder_new, expr_eval_from_string, fetchers_settings, fetchers_settings_free,20 fetchers_settings_new, flake_lock, flake_lock_flags, flake_lock_flags_free,21 flake_lock_flags_new, flake_reference_parse_flags, flake_reference_parse_flags_free,22 flake_reference_parse_flags_new, flake_reference_parse_flags_set_base_directory,23 flake_settings, flake_settings_free, flake_settings_new, init_bool, init_int, init_string,24 locked_flake_free, locked_flake_get_output_attrs, set_err_msg, setting_set, state_free,25 value_decref, value_incref,26};272829pub mod logging;30#[doc(hidden)]31pub mod macros;32pub mod util;3334#[allow(35 non_upper_case_globals,36 non_camel_case_types,37 non_snake_case,38 dead_code39)]40mod nix_raw {41 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));42}43#[cxx::bridge]44pub mod nix_cxx {45 unsafe extern "C++" {46 type nix_fetchers_settings;47 include!("nix-eval/src/lib.hh");4849 unsafe fn set_fetcher_setting(50 settings: *mut nix_fetchers_settings,51 setting: *const c_char,52 value: *const c_char,53 );54 }55}5657#[derive(Debug, PartialEq, Eq)]58pub enum NixType {59 Thunk,60 Int,61 Float,62 Bool,63 String,64 Path,65 Null,66 Attrs,67 List,68 Function,69 External,70}71impl NixType {72 fn from_int(c: c_uint) -> Self {73 match c {74 0 => Self::Thunk,75 1 => Self::Int,76 2 => Self::Float,77 3 => Self::Bool,78 4 => Self::String,79 5 => Self::Path,80 6 => Self::Null,81 7 => Self::Attrs,82 8 => Self::List,83 9 => Self::Function,84 10 => Self::External,85 _ => unreachable!("unknown nix type: {c}"),86 }87 }88}8990enum FunctorKind {91 Function,92 Functor,93}9495#[derive(Debug)]96#[repr(i32)]97enum NixErrorKind {98 Unknown = 1,99 Overflow = 2,100 Key = 3,101 Generic = 4,102}103impl NixErrorKind {104 fn from_int(v: c_int) -> Option<Self> {105 Some(match v {106 0 => return None,107 -1 => Self::Unknown,108 -2 => Self::Overflow,109 -3 => Self::Key,110 -4 => Self::Generic,111 _ => {112 debug_assert!(false, "unexpected nix error kind: {v}");113 Self::Unknown114 }115 })116 }117}118119pub fn gc_register_my_thread() {120 assert_eq!(unsafe { nix_raw::GC_thread_is_registered() }, 0);121122 let mut sb = nix_raw::GC_stack_base {123 mem_base: null_mut(),124 };125 let r = unsafe { nix_raw::GC_get_stack_base(&mut sb) };126 if r as u32 != nix_raw::GC_SUCCESS {127 panic!("failed to get thread stack base");128 }129 unsafe { nix_raw::GC_register_my_thread(&sb) };130}131pub fn gc_unregister_my_thread() {132 assert_eq!(unsafe { nix_raw::GC_thread_is_registered() }, 1);133134 unsafe { nix_raw::GC_unregister_my_thread() };135}136137pub struct ThreadRegisterGuard {}138impl ThreadRegisterGuard {139 pub fn new() -> Self {140 gc_register_my_thread();141 Self {}142 }143}144impl Drop for ThreadRegisterGuard {145 fn drop(&mut self) {146 gc_unregister_my_thread();147 }148}149150pub struct NixContext(*mut c_context);151impl NixContext {152 pub fn set_err(&mut self, err: NixErrorKind, msg: &CStr) {153 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };154 }155 pub fn new() -> Self {156 let ctx = unsafe { c_context_create() };157 Self(ctx)158 }159 fn error_kind(&self) -> Option<NixErrorKind> {160 let code = unsafe { err_code(self.0) };161 NixErrorKind::from_int(code)162 }163 fn error<'t>(&self) -> Option<Cow<'t, str>> {164 if let NixErrorKind::Generic = self.error_kind()? {165 let mut err_out = String::new();166 unsafe {167 err_info_msg(168 null_mut(),169 self.0,170 Some(copy_nix_str),171 (&raw mut err_out).cast(),172 )173 };174 return Some(Cow::Owned(err_out));175 };176177 178 179 let str = unsafe { nix_raw::err_msg(null_mut(), self.0, null_mut()) };180 Some(unsafe { CStr::from_ptr(str) }.to_string_lossy())181 }182 fn clean_err(&mut self) {183 unsafe {184 nix_raw::clear_err(self.0);185 }186 }187188 fn bail_if_error(&self) -> Result<()> {189 if let Some(err) = self.error() {190 bail!("{err}");191 };192 Ok(())193 }194195 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {196 self.clean_err();197 let o = f(self.0);198 self.bail_if_error()?;199 self.clean_err();200 Ok(o)201 }202}203impl Drop for NixContext {204 fn drop(&mut self) {205 unsafe {206 nix_raw::c_context_free(self.0);207 }208 }209}210struct GlobalState {211 212 #[allow(dead_code)]213 store: Store,214 state: EvalState,215}216impl GlobalState {217 fn new() -> Result<Self> {218 let mut ctx = NixContext::new();219 let store = ctx220 .run_in_context(|c| unsafe { nix_raw::store_open(c, c"daemon".as_ptr(), null_mut()) })221 .map(Store)?;222223 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;224 ctx.run_in_context(|c| {225 unsafe {226 nix_raw::eval_state_builder_set_eval_setting(227 c,228 builder,229 c"lazy-trees".as_ptr(),230 c"true".as_ptr(),231 )232 }233 234 })?;235 let state = ctx236 .run_in_context(|c| unsafe { eval_state_build(c, builder) })237 .map(EvalState)?;238239 Ok(Self { store, state })240 }241}242243struct ThreadState {244 ctx: NixContext,245}246impl ThreadState {247 fn new() -> Result<Self> {248 let ctx = NixContext::new();249250 Ok(Self { ctx })251 }252}253254static GLOBAL_STATE: LazyLock<GlobalState> =255 LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));256257thread_local! {258 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));259}260fn with_default_context<T>(261 f: impl FnOnce(*mut c_context, *mut nix_raw::EvalState) -> T,262) -> Result<T> {263 let global = &GLOBAL_STATE.state;264 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));265 let mut ctx = NixContext(ctx);266 let v = ctx.run_in_context(|c| f(c, state));267 268 std::mem::forget(ctx);269 v270}271272pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {273 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())274}275276pub struct FetchSettings(*mut fetchers_settings);277impl FetchSettings {278 pub fn new() -> Self {279 Self::try_new().expect("allocation should not fail")280 }281 fn try_new() -> Result<Self> {282 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)283 }284 pub fn set(&mut self, setting: &CStr, value: &CStr) {285 unsafe {286 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());287 };288 }289}290unsafe impl Send for FetchSettings {}291unsafe impl Sync for FetchSettings {}292293impl Default for FetchSettings {294 fn default() -> Self {295 Self::new()296 }297}298299impl Drop for FetchSettings {300 fn drop(&mut self) {301 unsafe { fetchers_settings_free(self.0) };302 }303}304pub struct FlakeSettings(*mut flake_settings);305impl FlakeSettings {306 pub fn new() -> Result<Self> {307 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)308 }309}310unsafe impl Send for FlakeSettings {}311unsafe impl Sync for FlakeSettings {}312impl Drop for FlakeSettings {313 fn drop(&mut self) {314 unsafe {315 flake_settings_free(self.0);316 }317 }318}319320pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);321impl FlakeReferenceParseFlags {322 pub fn new(settings: &mut FlakeSettings) -> Result<Self> {323 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })324 .map(Self)325 }326 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {327 with_default_context(|c, _| {328 unsafe {329 flake_reference_parse_flags_set_base_directory(330 c,331 self.0,332 dir.as_ptr().cast(),333 dir.len(),334 )335 };336 })337 }338}339impl Drop for FlakeReferenceParseFlags {340 fn drop(&mut self) {341 unsafe {342 flake_reference_parse_flags_free(self.0);343 }344 }345}346struct FlakeLockFlags(*mut flake_lock_flags);347impl FlakeLockFlags {348 fn new(settings: &mut FlakeSettings) -> Result<Self> {349 with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) }).map(Self)350 }351}352impl Drop for FlakeLockFlags {353 fn drop(&mut self) {354 unsafe {355 flake_lock_flags_free(self.0);356 }357 }358}359360unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {361 let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };362 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");363 unsafe { *user_data.cast::<String>() = s.to_owned() };364}365366struct Store(*mut nix_raw::Store);367unsafe impl Send for Store {}368unsafe impl Sync for Store {}369370struct EvalState(*mut nix_raw::EvalState);371unsafe impl Send for EvalState {}372unsafe impl Sync for EvalState {}373374impl Drop for EvalState {375 fn drop(&mut self) {376 unsafe {377 state_free(self.0);378 }379 }380}381382pub struct FlakeReference(*mut nix_raw::flake_reference);383impl FlakeReference {384 pub fn new(s: &str, fetch: &FetchSettings) -> Result<(Self, String)> {385 let mut flake_settings = FlakeSettings::new()?;386 let parse_flags = FlakeReferenceParseFlags::new(&mut flake_settings)?;387388 let mut out = null_mut();389 let mut fragment = String::new();390 391 with_default_context(|c, _| unsafe {392 nix_raw::flake_reference_and_fragment_from_string(393 c,394 fetch.0,395 flake_settings.0,396 parse_flags.0,397 s.as_ptr().cast(),398 s.len(),399 &mut out,400 Some(copy_nix_str),401 (&raw mut fragment).cast(),402 )403 })?;404 assert!(!out.is_null());405406 Ok((Self(out), fragment))407 }408 pub fn lock(&mut self, fetch: &FetchSettings) -> Result<LockedFlake> {409 let mut settings = FlakeSettings::new()?;410 let lock_flags = FlakeLockFlags::new(&mut settings)?;411 with_default_context(|c, es| unsafe {412 flake_lock(c, fetch.0, settings.0, es, lock_flags.0, self.0)413 })414 .map(LockedFlake)415 }416}417unsafe impl Send for FlakeReference {}418unsafe impl Sync for FlakeReference {}419420pub struct LockedFlake(*mut nix_raw::locked_flake);421impl LockedFlake {422 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {423 with_default_context(|c, es| unsafe {424 locked_flake_get_output_attrs(c, settings.0, es, self.0)425 })426 .map(Value)427 }428}429unsafe impl Send for LockedFlake {}430unsafe impl Sync for LockedFlake {}431impl Drop for LockedFlake {432 fn drop(&mut self) {433 unsafe {434 locked_flake_free(self.0);435 };436 }437}438439type FieldName = [u8; 32];440fn init_field_name(v: &str) -> FieldName {441 let mut f = [0; 32];442 assert!(v.len() < 32, "max field name is 31 char");443 assert!(444 v.bytes().all(|v| v != 0),445 "nul bytes are unsupported in field name"446 );447 f[0..v.len()].copy_from_slice(v.as_bytes());448 f449}450451pub struct RealisedString(*mut nix_raw::realised_string);452impl fmt::Debug for RealisedString {453 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {454 self.as_str().fmt(f)455 }456}457458impl RealisedString {459 pub fn as_str(&self) -> &str {460 let len = unsafe { nix_raw::realised_string_get_buffer_size(self.0) };461 let data: *const u8 = unsafe { nix_raw::realised_string_get_buffer_start(self.0) }.cast();462 let data = unsafe { std::slice::from_raw_parts(data, len) };463 std::str::from_utf8(data).expect("non-utf8 strings not supported")464 }465 pub fn path_count(&self) -> usize {466 unsafe { nix_raw::realised_string_get_store_path_count(self.0) }467 }468 pub fn path(&self, i: usize) -> String {469 assert!(i < self.path_count());470 let path = unsafe { nix_raw::realised_string_get_store_path(self.0, i) };471 let mut err_out = String::new();472 unsafe { nix_raw::store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };473 err_out474 }475}476477unsafe impl Send for RealisedString {}478impl Drop for RealisedString {479 fn drop(&mut self) {480 unsafe { nix_raw::realised_string_free(self.0) }481 }482}483484pub struct Value(*mut nix_raw::value);485486unsafe impl Send for Value {}487unsafe impl Sync for Value {}488489pub trait AsFieldName {490 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;491 fn to_field_name(&self) -> Result<String>;492}493impl AsFieldName for Value {494 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {495 let f = self.to_string()?;496 v(init_field_name(&f))497 }498 fn to_field_name(&self) -> Result<String> {499 self.to_string()500 }501}502impl<E> AsFieldName for E503where504 E: AsRef<str>,505{506 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {507 let f = self.as_ref();508 v(init_field_name(f))509 }510 fn to_field_name(&self) -> Result<String> {511 Ok(self.as_ref().to_owned())512 }513}514515struct AttrsBuilder(*mut nix_raw::BindingsBuilder);516impl AttrsBuilder {517 fn new(capacity: usize) -> Self {518 with_default_context(|c, es| unsafe { nix_raw::make_bindings_builder(c, es, capacity) })519 .map(Self)520 .expect("alloc should not fail")521 }522 fn insert(&mut self, k: &impl AsFieldName, v: Value) {523 k.as_field_name(|name| {524 with_default_context(|c, _| unsafe {525 nix_raw::bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0)526 })527 })528 .expect("builder insert shouldn't fail");529 }530}531impl Drop for AttrsBuilder {532 fn drop(&mut self) {533 unsafe { nix_raw::bindings_builder_free(self.0) };534 }535}536537impl Value {538 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {539 let out = Self::new_uninit();540 let mut b = AttrsBuilder::new(v.len());541 for (k, v) in v {542 b.insert(&k, v);543 }544 with_default_context(|c, _| unsafe { nix_raw::make_attrs(c, out.0, b.0) })545 .expect("attrs initialization should not fail");546 out547 }548 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {549 todo!()550 }551 fn new_uninit() -> Self {552 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })553 .expect("value allocation should not fail");554 Self(out)555 }556 pub fn new_str(v: &str) -> Self {557 let s = CString::new(v).expect("string should not contain NULs");558 let out = Self::new_uninit();559 560 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })561 .expect("string initialization should not fail");562 out563 }564 pub fn new_int(i: i64) -> Self {565 let out = Self::new_uninit();566 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })567 .expect("int initialization should not fail");568 out569 }570 pub fn new_bool(v: bool) -> Self {571 let out = Self::new_uninit();572 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })573 .expect("bool initialization should not fail");574 out575 }576 577 578 579 580 581 pub fn type_of(&self) -> NixType {582 let ty = with_default_context(|c, _| unsafe { nix_raw::get_type(c, self.0) })583 .expect("get_type should not fail");584 NixType::from_int(ty)585 }586 pub fn to_string(&self) -> Result<String> {587 Ok(self.to_realised_string()?.as_str().to_owned())588 }589 pub fn to_realised_string(&self) -> Result<RealisedString> {590 with_default_context(|c, es| unsafe { nix_raw::string_realise(c, es, self.0, false) })591 .map(RealisedString)592593 594 595 596 597 598 599 600 }601602 pub fn has_field(&self, field: &str) -> Result<bool> {603 let f = init_field_name(field);604 with_default_context(|c, es| unsafe {605 nix_raw::has_attr_byname(c, self.0, es, f.as_ptr().cast())606 })607 }608 609 610 611 pub fn list_fields(&self) -> Result<Vec<String>> {612 if !matches!(self.type_of(), NixType::Attrs) {613 bail!("invalid type: expected attrs");614 }615616 let len = with_default_context(|c, _| unsafe { nix_raw::get_attrs_size(c, self.0) })?;617 let mut out = Vec::with_capacity(len as usize);618619 for i in 0..len {620 let name = with_default_context(|c, es| unsafe {621 nix_raw::get_attr_name_byidx(c, self.0, es, i)622 })?;623 let c = unsafe { CStr::from_ptr(name) };624 out.push(c.to_str().expect("nix field names are utf-8").to_owned());625 }626 Ok(out)627 }628 pub fn get_elem(&self, v: usize) -> Result<Self> {629 if !matches!(self.type_of(), NixType::List) {630 bail!("invalid type: expected list");631 }632 let len =633 with_default_context(|c, _| unsafe { nix_raw::get_list_size(c, self.0) })? as usize;634 if v >= len {635 bail!("oob list get: {v} >= {len}");636 }637638 with_default_context(|c, es| unsafe { nix_raw::get_list_byidx(c, self.0, es, v as u32) })639 .map(Self)640 }641 pub fn attrs_update(self, other: Value) -> Result<Self> {642 let a_fields = self.list_fields()?;643 let b_fields = other.list_fields()?;644 match (a_fields.len(), b_fields.len()) {645 (_, 0) => return Ok(self),646 (0, _) => return Ok(other),647 _ => {}648 }649 let mut out = HashMap::new();650 for f in a_fields.iter() {651 if b_fields.contains(f) {652 break;653 }654 out.insert(f.as_str(), self.get_field(f)?);655 }656 if out.is_empty() {657 658 return Ok(other);659 }660 for f in b_fields.iter() {661 out.insert(f.as_str(), other.get_field(f)?);662 }663 Ok(Self::new_attrs(out))664 }665 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {666 if !matches!(self.type_of(), NixType::Attrs) {667 bail!("invalid type: expected attrs");668 }669670 name.as_field_name(|name| {671 with_default_context(|c, es| unsafe {672 nix_raw::get_attr_byname(c, self.0, es, name.as_ptr().cast())673 })674 .map(Self)675 })676 .with_context(|| format!("getting field {:?}", name.to_field_name()))677 }678 pub fn call(&self, v: Value) -> Result<Self> {679 let kind = self680 .functor_kind()681 .ok_or_else(|| anyhow!("can only call function or functor"))?;682683 let function = match kind {684 FunctorKind::Function => self.clone(),685 FunctorKind::Functor => {686 let f = self.get_field("__functor")?;687 assert_eq!(688 f.type_of(),689 NixType::Function,690 "invalid functor encountered"691 );692 f693 }694 };695696 let out = Value::new_uninit();697 with_default_context(|c, es| unsafe {698 nix_raw::value_call(c, es, function.0, v.0, out.0)699 })?;700701 Ok(out)702 }703 pub fn eval(v: &str) -> Result<Self> {704 let s = CString::new(v).expect("expression shouldn't have internal NULs");705 let out = Self::new_uninit();706 with_default_context(|c, es| unsafe {707 expr_eval_from_string(c, es, s.as_ptr(), c"/homeless-shelter".as_ptr(), out.0)708 })?;709 Ok(out)710 }711 pub async fn build(&self, output: &str) -> Result<PathBuf> {712 if !self.is_derivation() {713 bail!("expected derivation to build")714 }715 let output_name = self.get_field("outputName")?.to_string()?;716 let v = if output_name != output {717 let out = self.get_field(output)?;718 if !out.is_derivation() {719 bail!("unknown output: {output}");720 }721 out722 } else {723 self.clone()724 };725 726 let drv_path = tokio::task::spawn_blocking(move || v.get_field("outPath")?.to_string())727 .await728 .expect("should not fail")?;729 Ok(PathBuf::from(drv_path))730 }731 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {732 let to_json = Self::eval("builtins.toJSON")?;733 let s = to_json.call(self.clone())?.to_string()?;734 Ok(serde_json::from_str(&s)?)735 }736 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {737 Self::eval(&nixlike::serialize(v)?)738 }739740 741 742 743 744 745746 fn is_derivation(&self) -> bool {747 if !matches!(self.type_of(), NixType::Attrs) {748 return false;749 }750 let Some(ty) = self.get_field("type").ok() else {751 return false;752 };753 matches!(ty.to_string().as_deref(), Ok("derivation"))754 }755 fn functor_kind(&self) -> Option<FunctorKind> {756 match self.type_of() {757 NixType::Attrs => self758 .has_field("__functor")759 .expect("has_field shouldn't fail for attrs")760 .then_some(FunctorKind::Functor),761 NixType::Function => Some(FunctorKind::Function),762 _ => None,763 }764 }765 pub fn is_function(&self) -> bool {766 self.functor_kind().is_some()767 }768}769770impl From<String> for Value {771 fn from(value: String) -> Self {772 Value::new_str(&value)773 }774}775impl From<bool> for Value {776 fn from(value: bool) -> Self {777 Value::new_bool(value)778 }779}780impl From<&str> for Value {781 fn from(value: &str) -> Self {782 Value::new_str(value)783 }784}785impl<T> From<Vec<T>> for Value786where787 T: Into<Value>,788{789 fn from(value: Vec<T>) -> Self {790 Value::new_list(value)791 }792}793794impl Clone for Value {795 fn clone(&self) -> Self {796 with_default_context(|c, _| unsafe { value_incref(c, self.0) })797 .expect("value incref should not fail");798 Self(self.0)799 }800}801impl Drop for Value {802 fn drop(&mut self) {803 with_default_context(|c, _| unsafe { value_decref(c, self.0) })804 .expect("value drop should not fail");805 }806}807808pub fn init_libraries() {809 unsafe { nix_raw::GC_allow_register_threads() };810811 let mut ctx = NixContext::new();812 ctx.run_in_context(|c| unsafe { nix_raw::libutil_init(c) })813 .expect("util init should not fail");814 ctx.run_in_context(|c| unsafe { nix_raw::libstore_init(c) })815 .expect("store init should not fail");816 ctx.run_in_context(|c| unsafe { nix_raw::libexpr_init(c) })817 .expect("expr init should not fail");818819 nix_logging_cxx::apply_tracing_logger();820}821822#[test_log::test]823fn test_native() -> Result<()> {824 init_libraries();825826 let mut fetch_settings = FetchSettings::new();827 fetch_settings.set(c"warn-dirty", c"false");828829 let manifest = format!("{}/../../", env!("CARGO_MANIFEST_DIR"));830 let (mut r, _) = FlakeReference::new(&manifest, &fetch_settings)?;831 let locked = r.lock(&fetch_settings)?;832 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;833834 let builtins = Value::eval("builtins")?;835 assert_eq!(builtins.type_of(), NixType::Attrs);836837 assert_eq!(attrs.type_of(), NixType::Attrs);838 let test_data = nix_go!(attrs.testData);839840 let test_string: String = nix_go_json!(test_data.testString);841 assert_eq!(test_string, "hello");842843 Ok(())844}