From 25af4686806fa6e3c17888fed9174983a5a94e40 Mon Sep 17 00:00:00 2001 From: _cry64 Date: Thu, 2 Apr 2026 09:53:36 +1000 Subject: [PATCH] update all names in repo to match new bindings --- nixide-sys/tests/eval.rs | 313 +++++++++--------- nixide-sys/tests/flake.rs | 14 +- nixide-sys/tests/memory.rs | 137 ++++---- nixide-sys/tests/primop.rs | 129 ++++---- nixide-sys/tests/store.rs | 30 +- nixide-sys/tests/util.rs | 24 +- nixide/src/errors/context.rs | 95 +++--- nixide/src/errors/error.rs | 14 +- nixide/src/errors/nix_error.rs | 19 +- nixide/src/expr/eval_state_builder.rs | 10 +- nixide/src/expr/realised_string.rs | 12 +- nixide/src/expr/values/attrs.rs | 14 +- nixide/src/expr/values/bool.rs | 14 +- nixide/src/expr/values/float.rs | 14 +- nixide/src/expr/values/function.rs | 14 +- nixide/src/expr/values/int.rs | 14 +- nixide/src/expr/values/list.rs | 14 +- nixide/src/expr/values/mod.rs | 51 +-- nixide/src/expr/values/null.rs | 14 +- nixide/src/expr/values/path.rs | 14 +- nixide/src/expr/values/string.rs | 14 +- nixide/src/expr/values/thunk.rs | 14 +- nixide/src/flake/fetchers_settings.rs | 10 +- nixide/src/flake/flake_lock_flags.rs | 11 +- nixide/src/flake/flake_reference.rs | 12 +- .../src/flake/flake_reference_parse_flags.rs | 11 +- nixide/src/flake/flake_settings.rs | 10 +- nixide/src/flake/locked_flake.rs | 10 +- nixide/src/verbosity.rs | 33 +- 29 files changed, 526 insertions(+), 559 deletions(-) diff --git a/nixide-sys/tests/eval.rs b/nixide-sys/tests/eval.rs index c417850..e90dcbe 100644 --- a/nixide-sys/tests/eval.rs +++ b/nixide-sys/tests/eval.rs @@ -1,13 +1,12 @@ #![cfg(feature = "nix-expr-c")] #![cfg(test)] -use std::{ - ffi::{CStr, CString}, - ptr, -}; +use std::ffi::{CStr, CString}; +use std::ptr; + +use serial_test::serial; use nixide_sys::*; -use serial_test::serial; #[test] #[serial] @@ -16,13 +15,13 @@ fn eval_init_and_state_build() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libutil_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libutil_init failed: {err}"); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libstore_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libstore_init failed: {err}"); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libexpr_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}"); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -31,7 +30,7 @@ fn eval_init_and_state_build() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -51,20 +50,20 @@ fn eval_simple_expression() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libutil_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libutil_init failed: {err}"); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libstore_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libstore_init failed: {err}"); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK, "nix_libexpr_init failed: {err}"); + assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}"); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -76,11 +75,11 @@ fn eval_simple_expression() { assert!(!value.is_null()); let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value); - assert_eq!(eval_err, nix_err_NIX_OK); + assert_eq!(eval_err, NixErr::Ok); // Force the value (should not be a thunk) let force_err = nix_value_force(ctx, state, value); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); nix_state_free(state); nix_eval_state_builder_free(builder); @@ -96,25 +95,25 @@ fn value_construction_and_inspection() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); // Int let int_val = nix_alloc_value(ctx, state); assert!(!int_val.is_null()); - assert_eq!(nix_init_int(ctx, int_val, 42), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, int_val), ValueType_NIX_TYPE_INT); + assert_eq!(nix_init_int(ctx, int_val, 42), NixErr::Ok); + assert_eq!(nix_get_type(ctx, int_val), ValueType::Int); assert_eq!(nix_get_int(ctx, int_val), 42); // Float @@ -122,30 +121,30 @@ fn value_construction_and_inspection() { assert!(!float_val.is_null()); assert_eq!( nix_init_float(ctx, float_val, std::f64::consts::PI), - nix_err_NIX_OK + NixErr::Ok ); - assert_eq!(nix_get_type(ctx, float_val), ValueType_NIX_TYPE_FLOAT); + assert_eq!(nix_get_type(ctx, float_val), ValueType::Float); assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10); // Bool let bool_val = nix_alloc_value(ctx, state); assert!(!bool_val.is_null()); - assert_eq!(nix_init_bool(ctx, bool_val, true), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, bool_val), ValueType_NIX_TYPE_BOOL); + assert_eq!(nix_init_bool(ctx, bool_val, true), NixErr::Ok); + assert_eq!(nix_get_type(ctx, bool_val), ValueType::Bool); assert!(nix_get_bool(ctx, bool_val)); // Null let null_val = nix_alloc_value(ctx, state); assert!(!null_val.is_null()); - assert_eq!(nix_init_null(ctx, null_val), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, null_val), ValueType_NIX_TYPE_NULL); + assert_eq!(nix_init_null(ctx, null_val), NixErr::Ok); + assert_eq!(nix_get_type(ctx, null_val), ValueType::Null); // String let string_val = nix_alloc_value(ctx, state); assert!(!string_val.is_null()); let s = CString::new("hello world").unwrap(); - assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, string_val), ValueType_NIX_TYPE_STRING); + assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok); + assert_eq!(nix_get_type(ctx, string_val), ValueType::String); extern "C" fn string_cb( start: *const ::std::os::raw::c_char, n: ::std::os::raw::c_uint, @@ -159,7 +158,7 @@ fn value_construction_and_inspection() { let mut got: Option = None; assert_eq!( nix_get_string(ctx, string_val, Some(string_cb), (&raw mut got).cast()), - nix_err_NIX_OK + NixErr::Ok ); assert_eq!(got.as_deref(), Some("hello world")); @@ -169,9 +168,9 @@ fn value_construction_and_inspection() { let p = CString::new("/nix/store/foo").unwrap(); assert_eq!( nix_init_path_string(ctx, state, path_val, p.as_ptr()), - nix_err_NIX_OK + NixErr::Ok ); - assert_eq!(nix_get_type(ctx, path_val), ValueType_NIX_TYPE_PATH); + assert_eq!(nix_get_type(ctx, path_val), ValueType::Path); let path_ptr = nix_get_path_string(ctx, path_val); assert!(!path_ptr.is_null()); let path_str = CStr::from_ptr(path_ptr).to_string_lossy(); @@ -192,17 +191,17 @@ fn list_and_attrset_manipulation() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -220,15 +219,15 @@ fn list_and_attrset_manipulation() { nix_list_builder_insert(ctx, list_builder, 2, v3); let list_val = nix_alloc_value(ctx, state); - assert_eq!(nix_make_list(ctx, list_builder, list_val), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, list_val), ValueType_NIX_TYPE_LIST); + assert_eq!(nix_make_list(ctx, list_builder, list_val), NixErr::Ok); + assert_eq!(nix_get_type(ctx, list_val), ValueType::List); assert_eq!(nix_get_list_size(ctx, list_val), 3); // Get elements by index for i in 0..3 { let elem = nix_get_list_byidx(ctx, list_val, state, i); assert!(!elem.is_null()); - assert_eq!(nix_get_type(ctx, elem), ValueType_NIX_TYPE_INT); + assert_eq!(nix_get_type(ctx, elem), ValueType::Int); assert_eq!(nix_get_int(ctx, elem), i64::from(i + 1)); } @@ -248,19 +247,19 @@ fn list_and_attrset_manipulation() { nix_bindings_builder_insert(ctx, attr_builder, bar.as_ptr(), bar_val); let attr_val = nix_alloc_value(ctx, state); - assert_eq!(nix_make_attrs(ctx, attr_val, attr_builder), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, attr_val), ValueType_NIX_TYPE_ATTRS); + assert_eq!(nix_make_attrs(ctx, attr_val, attr_builder), NixErr::Ok); + assert_eq!(nix_get_type(ctx, attr_val), ValueType::Attrs); assert_eq!(nix_get_attrs_size(ctx, attr_val), 2); // Get by name let foo_got = nix_get_attr_byname(ctx, attr_val, state, foo.as_ptr()); assert!(!foo_got.is_null()); - assert_eq!(nix_get_type(ctx, foo_got), ValueType_NIX_TYPE_INT); + assert_eq!(nix_get_type(ctx, foo_got), ValueType::Int); assert_eq!(nix_get_int(ctx, foo_got), 42); let bar_got = nix_get_attr_byname(ctx, attr_val, state, bar.as_ptr()); assert!(!bar_got.is_null()); - assert_eq!(nix_get_type(ctx, bar_got), ValueType_NIX_TYPE_STRING); + assert_eq!(nix_get_type(ctx, bar_got), ValueType::String); // Has attr assert!(nix_has_attr_byname(ctx, attr_val, state, foo.as_ptr())); @@ -282,17 +281,17 @@ fn function_application_and_force() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -303,7 +302,7 @@ fn function_application_and_force() { assert!(!fn_val.is_null()); assert_eq!( nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), fn_val), - nix_err_NIX_OK + NixErr::Ok ); // Argument: 41 @@ -315,16 +314,16 @@ fn function_application_and_force() { assert!(!result_val.is_null()); assert_eq!( nix_value_call(ctx, state, fn_val, arg_val, result_val), - nix_err_NIX_OK + NixErr::Ok ); // Force result - assert_eq!(nix_value_force(ctx, state, result_val), nix_err_NIX_OK); - assert_eq!(nix_get_type(ctx, result_val), ValueType_NIX_TYPE_INT); + assert_eq!(nix_value_force(ctx, state, result_val), NixErr::Ok); + assert_eq!(nix_get_type(ctx, result_val), ValueType::Int); assert_eq!(nix_get_int(ctx, result_val), 42); // Deep force (should be a no-op for int) - assert_eq!(nix_value_force_deep(ctx, state, result_val), nix_err_NIX_OK); + assert_eq!(nix_value_force_deep(ctx, state, result_val), NixErr::Ok); nix_state_free(state); nix_eval_state_builder_free(builder); @@ -340,17 +339,17 @@ fn error_handling_invalid_expression() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -360,7 +359,7 @@ fn error_handling_invalid_expression() { let value = nix_alloc_value(ctx, state); assert!(!value.is_null()); let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value); - assert_ne!(eval_err, nix_err_NIX_OK); + assert_ne!(eval_err, NixErr::Ok); nix_state_free(state); nix_eval_state_builder_free(builder); @@ -376,24 +375,24 @@ fn realised_string_and_gc() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); // String value let string_val = nix_alloc_value(ctx, state); let s = CString::new("hello world").unwrap(); - assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), nix_err_NIX_OK); + assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok); // Realise string let realised = nix_string_realise(ctx, state, string_val, false); @@ -422,18 +421,18 @@ fn big_thunk_evaluation() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); assert!(!builder.is_null()); - assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK); + assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -446,10 +445,10 @@ fn big_thunk_evaluation() { assert!(!value.is_null()); let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value); - assert_eq!(eval_err, nix_err_NIX_OK); + assert_eq!(eval_err, NixErr::Ok); // The top-level should be an attrset - assert_eq!(nix_get_type(ctx, value), ValueType_NIX_TYPE_ATTRS); + assert_eq!(nix_get_type(ctx, value), ValueType::Attrs); // Get "result" attribute (ts should be a thunk initially) let result_name = CString::new("result").unwrap(); @@ -458,9 +457,9 @@ fn big_thunk_evaluation() { // Force the result let force_err = nix_value_force(ctx, state, result_val); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); - assert_eq!(nix_get_type(ctx, result_val), ValueType_NIX_TYPE_INT); + assert_eq!(nix_get_type(ctx, result_val), ValueType::Int); assert_eq!(nix_get_int(ctx, result_val), 13); // ((1+2)*3)+4 = 13 // Get "other" attribute @@ -469,9 +468,9 @@ fn big_thunk_evaluation() { assert!(!other_val.is_null()); let force_err2 = nix_value_force(ctx, state, other_val); - assert_eq!(force_err2, nix_err_NIX_OK); + assert_eq!(force_err2, NixErr::Ok); - assert_eq!(nix_get_type(ctx, other_val), ValueType_NIX_TYPE_INT); + assert_eq!(nix_get_type(ctx, other_val), ValueType::Int); assert_eq!(nix_get_int(ctx, other_val), 3); // 1+2 = 3 nix_state_free(state); @@ -489,13 +488,13 @@ fn multi_argument_function_calls() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -504,7 +503,7 @@ fn multi_argument_function_calls() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -518,15 +517,15 @@ fn multi_argument_function_calls() { let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), func_value); - assert_eq!(eval_err, nix_err_NIX_OK); + assert_eq!(eval_err, NixErr::Ok); // Force evaluation of the function let force_err = nix_value_force(ctx, state, func_value); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); // Verify it's a function let func_type = nix_get_type(ctx, func_value); - assert_eq!(func_type, ValueType_NIX_TYPE_FUNCTION); + assert_eq!(func_type, ValueType::Function); // Create arguments let arg1 = nix_alloc_value(ctx, state); @@ -535,8 +534,8 @@ fn multi_argument_function_calls() { let init_arg1_err = nix_init_int(ctx, arg1, 10); let init_arg2_err = nix_init_int(ctx, arg2, 20); - assert_eq!(init_arg1_err, nix_err_NIX_OK); - assert_eq!(init_arg2_err, nix_err_NIX_OK); + assert_eq!(init_arg1_err, NixErr::Ok); + assert_eq!(init_arg2_err, NixErr::Ok); // Test multi-argument call using nix_value_call_multi let mut args = [arg1, arg2]; @@ -544,15 +543,15 @@ fn multi_argument_function_calls() { assert!(!result.is_null()); let call_err = nix_value_call_multi(ctx, state, func_value, 2, args.as_mut_ptr(), result); - assert_eq!(call_err, nix_err_NIX_OK); + assert_eq!(call_err, NixErr::Ok); // Force the result let force_result_err = nix_value_force(ctx, state, result); - assert_eq!(force_result_err, nix_err_NIX_OK); + assert_eq!(force_result_err, NixErr::Ok); // Check result type and value let result_type = nix_get_type(ctx, result); - assert_eq!(result_type, ValueType_NIX_TYPE_INT); + assert_eq!(result_type, ValueType::Int); let result_value = nix_get_int(ctx, result); assert_eq!(result_value, 30); // 10 + 20 @@ -577,13 +576,13 @@ fn curried_function_evaluation() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -592,7 +591,7 @@ fn curried_function_evaluation() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -606,7 +605,7 @@ fn curried_function_evaluation() { let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), func_value); - assert_eq!(eval_err, nix_err_NIX_OK); + assert_eq!(eval_err, NixErr::Ok); // Create three arguments let arg1 = nix_alloc_value(ctx, state); @@ -624,15 +623,15 @@ fn curried_function_evaluation() { assert!(!result.is_null()); let call_err = nix_value_call_multi(ctx, state, func_value, 3, args.as_mut_ptr(), result); - assert_eq!(call_err, nix_err_NIX_OK); + assert_eq!(call_err, NixErr::Ok); // Force the result let force_result_err = nix_value_force(ctx, state, result); - assert_eq!(force_result_err, nix_err_NIX_OK); + assert_eq!(force_result_err, NixErr::Ok); // Check result let result_type = nix_get_type(ctx, result); - assert_eq!(result_type, ValueType_NIX_TYPE_INT); + assert_eq!(result_type, ValueType::Int); let result_value = nix_get_int(ctx, result); assert_eq!(result_value, 30); // 5 + 10 + 15 @@ -642,42 +641,42 @@ fn curried_function_evaluation() { assert!(!partial1.is_null()); let partial_call1_err = nix_value_call(ctx, state, func_value, arg1, partial1); - assert_eq!(partial_call1_err, nix_err_NIX_OK); + assert_eq!(partial_call1_err, NixErr::Ok); // partial1 should still be a function let force_partial1_err = nix_value_force(ctx, state, partial1); - assert_eq!(force_partial1_err, nix_err_NIX_OK); + assert_eq!(force_partial1_err, NixErr::Ok); let partial1_type = nix_get_type(ctx, partial1); - assert_eq!(partial1_type, ValueType_NIX_TYPE_FUNCTION); + assert_eq!(partial1_type, ValueType::Function); // Apply second argument let partial2 = nix_alloc_value(ctx, state); assert!(!partial2.is_null()); let partial_call2_err = nix_value_call(ctx, state, partial1, arg2, partial2); - assert_eq!(partial_call2_err, nix_err_NIX_OK); + assert_eq!(partial_call2_err, NixErr::Ok); // partial2 should still be a function let force_partial2_err = nix_value_force(ctx, state, partial2); - assert_eq!(force_partial2_err, nix_err_NIX_OK); + assert_eq!(force_partial2_err, NixErr::Ok); let partial2_type = nix_get_type(ctx, partial2); - assert_eq!(partial2_type, ValueType_NIX_TYPE_FUNCTION); + assert_eq!(partial2_type, ValueType::Function); // Apply final argument let final_result = nix_alloc_value(ctx, state); assert!(!final_result.is_null()); let final_call_err = nix_value_call(ctx, state, partial2, arg3, final_result); - assert_eq!(final_call_err, nix_err_NIX_OK); + assert_eq!(final_call_err, NixErr::Ok); // Force and check final result let force_final_err = nix_value_force(ctx, state, final_result); - assert_eq!(force_final_err, nix_err_NIX_OK); + assert_eq!(force_final_err, NixErr::Ok); let final_type = nix_get_type(ctx, final_result); - assert_eq!(final_type, ValueType_NIX_TYPE_INT); + assert_eq!(final_type, ValueType::Int); let final_value = nix_get_int(ctx, final_result); assert_eq!(final_value, 30); // same result as multi-arg call @@ -706,13 +705,13 @@ fn thunk_creation_with_init_apply() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -721,7 +720,7 @@ fn thunk_creation_with_init_apply() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -735,33 +734,33 @@ fn thunk_creation_with_init_apply() { let eval_err = nix_expr_eval_from_string(ctx, state, func_expr.as_ptr(), path.as_ptr(), func_value); - assert_eq!(eval_err, nix_err_NIX_OK); + assert_eq!(eval_err, NixErr::Ok); // Create an argument let arg = nix_alloc_value(ctx, state); assert!(!arg.is_null()); let init_arg_err = nix_init_int(ctx, arg, 21); - assert_eq!(init_arg_err, nix_err_NIX_OK); + assert_eq!(init_arg_err, NixErr::Ok); // Create a thunk using nix_init_apply (lazy evaluation) let thunk = nix_alloc_value(ctx, state); assert!(!thunk.is_null()); let apply_err = nix_init_apply(ctx, thunk, func_value, arg); - assert_eq!(apply_err, nix_err_NIX_OK); + assert_eq!(apply_err, NixErr::Ok); // Initially, the thunk should be of type THUNK let thunk_type = nix_get_type(ctx, thunk); - assert_eq!(thunk_type, ValueType_NIX_TYPE_THUNK); + assert_eq!(thunk_type, ValueType::Thunk); // Force evaluation of the thunk let force_err = nix_value_force(ctx, state, thunk); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); // After forcing, it should be an integer let forced_type = nix_get_type(ctx, thunk); - assert_eq!(forced_type, ValueType_NIX_TYPE_INT); + assert_eq!(forced_type, ValueType::Int); let result_value = nix_get_int(ctx, thunk); assert_eq!(result_value, 42); // 21 * 2 @@ -785,13 +784,13 @@ fn lookup_path_configuration() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -814,10 +813,10 @@ fn lookup_path_configuration() { builder, lookup_path_ptrs_null_terminated.as_mut_ptr(), ); - assert_eq!(set_lookup_err, nix_err_NIX_OK); + assert_eq!(set_lookup_err, NixErr::Ok); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -836,12 +835,12 @@ fn lookup_path_configuration() { // The evaluation might succeed or fail depending on Nix version and // configuration The important thing is that setting the lookup path // didn't crash - if eval_err == nix_err_NIX_OK { + if eval_err == NixErr::Ok { let force_err = nix_value_force(ctx, state, result); - if force_err == nix_err_NIX_OK { + if force_err == NixErr::Ok { let result_type = nix_get_type(ctx, result); // nixPath should be a list - assert_eq!(result_type, ValueType_NIX_TYPE_LIST); + assert_eq!(result_type, ValueType::List); } } @@ -862,13 +861,13 @@ fn complex_nested_evaluation() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -877,7 +876,7 @@ fn complex_nested_evaluation() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -907,7 +906,7 @@ fn complex_nested_evaluation() { // Complex expressions may fail sometimes, check for both success // and error - if eval_err != nix_err_NIX_OK { + if eval_err != NixErr::Ok { // If evaluation fails, skip the rest of the test nix_value_decref(ctx, result); nix_state_free(state); @@ -919,7 +918,7 @@ fn complex_nested_evaluation() { // Force deep evaluation let force_err = nix_value_force_deep(ctx, state, result); - if force_err != nix_err_NIX_OK { + if force_err != NixErr::Ok { // If forcing fails, skip the rest of the test nix_value_decref(ctx, result); nix_state_free(state); @@ -931,7 +930,7 @@ fn complex_nested_evaluation() { // Verify result structure let result_type = nix_get_type(ctx, result); - assert_eq!(result_type, ValueType_NIX_TYPE_ATTRS); + assert_eq!(result_type, ValueType::Attrs); let attrs_size = nix_get_attrs_size(ctx, result); assert_eq!(attrs_size, 2); // original, sum @@ -942,7 +941,7 @@ fn complex_nested_evaluation() { assert!(!sum_value.is_null()); let sum_type = nix_get_type(ctx, sum_value); - assert_eq!(sum_type, ValueType_NIX_TYPE_INT); + assert_eq!(sum_type, ValueType::Int); let sum_result = nix_get_int(ctx, sum_value); assert_eq!(sum_result, 15); // 1 + 2 + 3 + 4 + 5 @@ -952,7 +951,7 @@ fn complex_nested_evaluation() { let original_value = nix_get_attr_byname(ctx, result, state, original_key.as_ptr()); if !original_value.is_null() { let original_type = nix_get_type(ctx, original_value); - assert_eq!(original_type, ValueType_NIX_TYPE_LIST); + assert_eq!(original_type, ValueType::List); let original_size = nix_get_list_size(ctx, original_value); assert_eq!(original_size, 5); @@ -961,7 +960,7 @@ fn complex_nested_evaluation() { let first_elem = nix_get_list_byidx(ctx, original_value, state, 0); if !first_elem.is_null() { let first_elem_type = nix_get_type(ctx, first_elem); - assert_eq!(first_elem_type, ValueType_NIX_TYPE_INT); + assert_eq!(first_elem_type, ValueType::Int); let first_elem_value = nix_get_int(ctx, first_elem); assert_eq!(first_elem_value, 1); @@ -985,13 +984,13 @@ fn evaluation_error_handling() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -1000,7 +999,7 @@ fn evaluation_error_handling() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -1014,7 +1013,7 @@ fn evaluation_error_handling() { let eval_err = nix_expr_eval_from_string(ctx, state, invalid_expr.as_ptr(), path.as_ptr(), result); - assert_ne!(eval_err, nix_err_NIX_OK); // should fail + assert_ne!(eval_err, NixErr::Ok); // should fail // Clear error for next test nix_clear_err(ctx); @@ -1034,14 +1033,14 @@ fn evaluation_error_handling() { ); // May succeed at parse time but fail during evaluation - if eval_err2 == nix_err_NIX_OK { + if eval_err2 == NixErr::Ok { let force_err = nix_value_force(ctx, state, result2); - assert_ne!(force_err, nix_err_NIX_OK); // should fail during forcing + assert_ne!(force_err, NixErr::Ok); // should fail during forcing } // Test error information retrieval let error_code = nix_err_code(ctx); - assert_ne!(error_code, nix_err_NIX_OK); + assert_ne!(error_code, NixErr::Ok); // Try to get error message let mut error_len: std::os::raw::c_uint = 0; @@ -1065,7 +1064,7 @@ fn evaluation_error_handling() { let eval_func_err = nix_expr_eval_from_string(ctx, state, func_expr.as_ptr(), path.as_ptr(), func_value); - assert_eq!(eval_func_err, nix_err_NIX_OK); + assert_eq!(eval_func_err, NixErr::Ok); // Try to call with wrong number of arguments. // The function expects 2, but we give 1 @@ -1087,12 +1086,12 @@ fn evaluation_error_handling() { ); // This should succeed but result should be a partially applied function - if call_err == nix_err_NIX_OK { + if call_err == NixErr::Ok { let force_err = nix_value_force(ctx, state, result3); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); let result_type = nix_get_type(ctx, result3); - assert_eq!(result_type, ValueType_NIX_TYPE_FUNCTION); // partially applied + assert_eq!(result_type, ValueType::Function); // partially applied } // Clean up @@ -1116,13 +1115,13 @@ fn builtin_function_calls() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -1131,7 +1130,7 @@ fn builtin_function_calls() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -1145,7 +1144,7 @@ fn builtin_function_calls() { let eval_length_err = nix_expr_eval_from_string(ctx, state, length_expr.as_ptr(), path.as_ptr(), length_func); - assert_eq!(eval_length_err, nix_err_NIX_OK); + assert_eq!(eval_length_err, NixErr::Ok); // Create a list to test with let list_expr = CString::new("[1 2 3 4 5]").unwrap(); @@ -1154,20 +1153,20 @@ fn builtin_function_calls() { let eval_list_err = nix_expr_eval_from_string(ctx, state, list_expr.as_ptr(), path.as_ptr(), test_list); - assert_eq!(eval_list_err, nix_err_NIX_OK); + assert_eq!(eval_list_err, NixErr::Ok); // Call length function with the list let length_result = nix_alloc_value(ctx, state); assert!(!length_result.is_null()); let call_length_err = nix_value_call(ctx, state, length_func, test_list, length_result); - assert_eq!(call_length_err, nix_err_NIX_OK); + assert_eq!(call_length_err, NixErr::Ok); let force_length_err = nix_value_force(ctx, state, length_result); - assert_eq!(force_length_err, nix_err_NIX_OK); + assert_eq!(force_length_err, NixErr::Ok); let length_type = nix_get_type(ctx, length_result); - assert_eq!(length_type, ValueType_NIX_TYPE_INT); + assert_eq!(length_type, ValueType::Int); let length_value = nix_get_int(ctx, length_result); assert_eq!(length_value, 5); @@ -1179,7 +1178,7 @@ fn builtin_function_calls() { let eval_map_err = nix_expr_eval_from_string(ctx, state, map_expr.as_ptr(), path.as_ptr(), map_func); - assert_eq!(eval_map_err, nix_err_NIX_OK); + assert_eq!(eval_map_err, NixErr::Ok); // Create a simple function to map: (x: x * 2) let double_expr = CString::new("(x: x * 2)").unwrap(); @@ -1188,7 +1187,7 @@ fn builtin_function_calls() { let eval_double_err = nix_expr_eval_from_string(ctx, state, double_expr.as_ptr(), path.as_ptr(), double_func); - assert_eq!(eval_double_err, nix_err_NIX_OK); + assert_eq!(eval_double_err, NixErr::Ok); // Call map with the function and list let mut args = [double_func, test_list]; @@ -1197,13 +1196,13 @@ fn builtin_function_calls() { let call_map_err = nix_value_call_multi(ctx, state, map_func, 2, args.as_mut_ptr(), map_result); - assert_eq!(call_map_err, nix_err_NIX_OK); + assert_eq!(call_map_err, NixErr::Ok); let force_map_err = nix_value_force(ctx, state, map_result); - assert_eq!(force_map_err, nix_err_NIX_OK); + assert_eq!(force_map_err, NixErr::Ok); let map_result_type = nix_get_type(ctx, map_result); - assert_eq!(map_result_type, ValueType_NIX_TYPE_LIST); + assert_eq!(map_result_type, ValueType::List); let map_result_size = nix_get_list_size(ctx, map_result); assert_eq!(map_result_size, 5); @@ -1213,10 +1212,10 @@ fn builtin_function_calls() { assert!(!first_mapped.is_null()); let force_first_err = nix_value_force(ctx, state, first_mapped); - assert_eq!(force_first_err, nix_err_NIX_OK); + assert_eq!(force_first_err, NixErr::Ok); let first_mapped_type = nix_get_type(ctx, first_mapped); - assert_eq!(first_mapped_type, ValueType_NIX_TYPE_INT); + assert_eq!(first_mapped_type, ValueType::Int); let first_mapped_value = nix_get_int(ctx, first_mapped); assert_eq!(first_mapped_value, 2); // 1 * 2 diff --git a/nixide-sys/tests/flake.rs b/nixide-sys/tests/flake.rs index d9f67c8..c6232c5 100644 --- a/nixide-sys/tests/flake.rs +++ b/nixide-sys/tests/flake.rs @@ -3,9 +3,10 @@ use std::ptr; -use nixide_sys::*; use serial_test::serial; +use nixide_sys::*; + #[test] #[serial] fn flake_settings_new_and_free() { @@ -32,13 +33,13 @@ fn flake_settings_add_to_eval_state_builder() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); @@ -53,9 +54,8 @@ fn flake_settings_add_to_eval_state_builder() { let err = nix_flake_settings_add_to_eval_state_builder(ctx, settings, builder); // Accept OK or ERR_UNKNOWN (depends on Nix build/config) assert!( - err == nix_err_NIX_OK || err == nix_err_NIX_ERR_UNKNOWN, - "nix_flake_settings_add_to_eval_state_builder returned unexpected error \ - code: {err}" + err == NixErr::Ok || err == NixErr::Unknown, + "nix_flake_settings_add_to_eval_state_builder returned unexpected error code: {err}" ); nix_flake_settings_free(settings); diff --git a/nixide-sys/tests/memory.rs b/nixide-sys/tests/memory.rs index 4ac8702..c7b83db 100644 --- a/nixide-sys/tests/memory.rs +++ b/nixide-sys/tests/memory.rs @@ -3,9 +3,10 @@ use std::ffi::CString; -use nixide_sys::*; use serial_test::serial; +use nixide_sys::*; + #[test] #[serial] fn value_reference_counting() { @@ -14,13 +15,13 @@ fn value_reference_counting() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -29,7 +30,7 @@ fn value_reference_counting() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -40,11 +41,11 @@ fn value_reference_counting() { // Initialize with an integer let init_err = nix_init_int(ctx, value, 42); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Test value-specific reference counting let incref_err = nix_value_incref(ctx, value); - assert_eq!(incref_err, nix_err_NIX_OK); + assert_eq!(incref_err, NixErr::Ok); // Value should still be valid after increment let int_val = nix_get_int(ctx, value); @@ -52,7 +53,7 @@ fn value_reference_counting() { // Test decrement let decref_err = nix_value_decref(ctx, value); - assert_eq!(decref_err, nix_err_NIX_OK); + assert_eq!(decref_err, NixErr::Ok); // Value should still be valid (original reference still exists) let int_val2 = nix_get_int(ctx, value); @@ -60,7 +61,7 @@ fn value_reference_counting() { // Final decrement (should not crash) let final_decref_err = nix_value_decref(ctx, value); - assert_eq!(final_decref_err, nix_err_NIX_OK); + assert_eq!(final_decref_err, NixErr::Ok); // Clean up nix_state_free(state); @@ -78,13 +79,13 @@ fn general_gc_reference_counting() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -93,7 +94,7 @@ fn general_gc_reference_counting() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -107,19 +108,19 @@ fn general_gc_reference_counting() { value, CString::new("test string for GC").unwrap().as_ptr(), ); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Test general GC reference counting let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void); - assert_eq!(gc_incref_err, nix_err_NIX_OK); + assert_eq!(gc_incref_err, NixErr::Ok); // Value should still be accessible let value_type = nix_get_type(ctx, value); - assert_eq!(value_type, ValueType_NIX_TYPE_STRING); + assert_eq!(value_type, ValueType::String); // Test GC decrement let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void); - assert_eq!(gc_decref_err, nix_err_NIX_OK); + assert_eq!(gc_decref_err, NixErr::Ok); // Final cleanup nix_value_decref(ctx, value); @@ -138,13 +139,13 @@ fn manual_garbage_collection() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -153,7 +154,7 @@ fn manual_garbage_collection() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -164,7 +165,7 @@ fn manual_garbage_collection() { let value = nix_alloc_value(ctx, state); if !value.is_null() { let init_err = nix_init_int(ctx, value, i); - if init_err == nix_err_NIX_OK { + if init_err == NixErr::Ok { values.push(value); } } @@ -196,13 +197,13 @@ fn value_copying_and_memory_management() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -211,7 +212,7 @@ fn value_copying_and_memory_management() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -222,20 +223,20 @@ fn value_copying_and_memory_management() { let test_string = CString::new("test string for copying").unwrap(); let init_err = nix_init_string(ctx, original, test_string.as_ptr()); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Create copy let copy = nix_alloc_value(ctx, state); assert!(!copy.is_null()); let copy_err = nix_copy_value(ctx, copy, original); - assert_eq!(copy_err, nix_err_NIX_OK); + assert_eq!(copy_err, NixErr::Ok); // Verify copy has same type and can be accessed let original_type = nix_get_type(ctx, original); let copy_type = nix_get_type(ctx, copy); assert_eq!(original_type, copy_type); - assert_eq!(copy_type, ValueType_NIX_TYPE_STRING); + assert_eq!(copy_type, ValueType::String); // Test string contents using callback unsafe extern "C" fn string_callback( @@ -268,20 +269,22 @@ fn value_copying_and_memory_management() { // Both should have the same string content assert_eq!(original_string, copy_string); - assert!(original_string - .as_deref() - .unwrap_or("") - .contains("test string")); + assert!( + original_string + .as_deref() + .unwrap_or("") + .contains("test string") + ); // Test reference counting on both values let incref_orig = nix_value_incref(ctx, original); let incref_copy = nix_value_incref(ctx, copy); - assert_eq!(incref_orig, nix_err_NIX_OK); - assert_eq!(incref_copy, nix_err_NIX_OK); + assert_eq!(incref_orig, NixErr::Ok); + assert_eq!(incref_copy, NixErr::Ok); // Values should still be accessible after increment - assert_eq!(nix_get_type(ctx, original), ValueType_NIX_TYPE_STRING); - assert_eq!(nix_get_type(ctx, copy), ValueType_NIX_TYPE_STRING); + assert_eq!(nix_get_type(ctx, original), ValueType::String); + assert_eq!(nix_get_type(ctx, copy), ValueType::String); // Clean up with decrements nix_value_decref(ctx, original); @@ -304,13 +307,13 @@ fn complex_value_memory_management() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -319,7 +322,7 @@ fn complex_value_memory_management() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -343,7 +346,7 @@ fn complex_value_memory_management() { let _ = nix_init_string(ctx, val1, name_str.as_ptr()); let insert_err1 = nix_bindings_builder_insert(ctx, bindings_builder1, key1.as_ptr(), val1); - assert_eq!(insert_err1, nix_err_NIX_OK); + assert_eq!(insert_err1, NixErr::Ok); let key2 = CString::new("value").unwrap(); let val2 = nix_alloc_value(ctx, state); @@ -351,14 +354,14 @@ fn complex_value_memory_management() { let _ = nix_init_int(ctx, val2, 42); let insert_err2 = nix_bindings_builder_insert(ctx, bindings_builder1, key2.as_ptr(), val2); - assert_eq!(insert_err2, nix_err_NIX_OK); + assert_eq!(insert_err2, NixErr::Ok); let make_attrs_err1 = nix_make_attrs(ctx, attrs1, bindings_builder1); - assert_eq!(make_attrs_err1, nix_err_NIX_OK); + assert_eq!(make_attrs_err1, NixErr::Ok); // Insert first attrs into list let list_insert_err1 = nix_list_builder_insert(ctx, list_builder, 0, attrs1); - assert_eq!(list_insert_err1, nix_err_NIX_OK); + assert_eq!(list_insert_err1, NixErr::Ok); // Create second element let attrs2 = nix_alloc_value(ctx, state); @@ -374,23 +377,23 @@ fn complex_value_memory_management() { let _ = nix_init_string(ctx, val3, data_str.as_ptr()); let insert_err3 = nix_bindings_builder_insert(ctx, bindings_builder2, key3.as_ptr(), val3); - assert_eq!(insert_err3, nix_err_NIX_OK); + assert_eq!(insert_err3, NixErr::Ok); let make_attrs_err2 = nix_make_attrs(ctx, attrs2, bindings_builder2); - assert_eq!(make_attrs_err2, nix_err_NIX_OK); + assert_eq!(make_attrs_err2, NixErr::Ok); let list_insert_err2 = nix_list_builder_insert(ctx, list_builder, 1, attrs2); - assert_eq!(list_insert_err2, nix_err_NIX_OK); + assert_eq!(list_insert_err2, NixErr::Ok); // Create final list let final_list = nix_alloc_value(ctx, state); assert!(!final_list.is_null()); let make_list_err = nix_make_list(ctx, list_builder, final_list); - assert_eq!(make_list_err, nix_err_NIX_OK); + assert_eq!(make_list_err, NixErr::Ok); // Test the complex structure - assert_eq!(nix_get_type(ctx, final_list), ValueType_NIX_TYPE_LIST); + assert_eq!(nix_get_type(ctx, final_list), ValueType::List); assert_eq!(nix_get_list_size(ctx, final_list), 2); // Access nested elements @@ -398,19 +401,19 @@ fn complex_value_memory_management() { let elem1 = nix_get_list_byidx(ctx, final_list, state, 1); assert!(!elem0.is_null() && !elem1.is_null()); - assert_eq!(nix_get_type(ctx, elem0), ValueType_NIX_TYPE_ATTRS); - assert_eq!(nix_get_type(ctx, elem1), ValueType_NIX_TYPE_ATTRS); + assert_eq!(nix_get_type(ctx, elem0), ValueType::Attrs); + assert_eq!(nix_get_type(ctx, elem1), ValueType::Attrs); // Test memory management with deep copying let copied_list = nix_alloc_value(ctx, state); assert!(!copied_list.is_null()); let copy_err = nix_copy_value(ctx, copied_list, final_list); - assert_eq!(copy_err, nix_err_NIX_OK); + assert_eq!(copy_err, NixErr::Ok); // Force deep evaluation on copy let deep_force_err = nix_value_force_deep(ctx, state, copied_list); - assert_eq!(deep_force_err, nix_err_NIX_OK); + assert_eq!(deep_force_err, NixErr::Ok); // Both should still be accessible assert_eq!(nix_get_list_size(ctx, final_list), 2); @@ -443,34 +446,28 @@ fn memory_management_error_conditions() { // XXX: May succeed or fail depending on implementation. We can't really // know, so assert both. - assert!(null_incref_err == nix_err_NIX_OK || null_incref_err == nix_err_NIX_ERR_UNKNOWN); + assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown); let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void); - assert!(null_decref_err == nix_err_NIX_OK || null_decref_err == nix_err_NIX_ERR_UNKNOWN); + assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown); let null_value_incref_err = nix_value_incref(ctx, std::ptr::null_mut()); // Some Nix APIs gracefully handle null pointers and return OK - assert!( - null_value_incref_err == nix_err_NIX_OK - || null_value_incref_err == nix_err_NIX_ERR_UNKNOWN - ); + assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown); let null_value_decref_err = nix_value_decref(ctx, std::ptr::null_mut()); // Some Nix APIs gracefully handle null pointers and return OK - assert!( - null_value_decref_err == nix_err_NIX_OK - || null_value_decref_err == nix_err_NIX_ERR_UNKNOWN - ); + assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown); // Test copy with NULL values let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -479,7 +476,7 @@ fn memory_management_error_conditions() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -489,10 +486,10 @@ fn memory_management_error_conditions() { // Test copying to/from NULL let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut()); - assert_ne!(copy_from_null_err, nix_err_NIX_OK); + assert_ne!(copy_from_null_err, NixErr::Ok); let copy_to_null_err = nix_copy_value(ctx, std::ptr::null_mut(), valid_value); - assert_ne!(copy_to_null_err, nix_err_NIX_OK); + assert_ne!(copy_to_null_err, NixErr::Ok); // Clean up nix_value_decref(ctx, valid_value); diff --git a/nixide-sys/tests/primop.rs b/nixide-sys/tests/primop.rs index 257faaf..2a0b62a 100644 --- a/nixide-sys/tests/primop.rs +++ b/nixide-sys/tests/primop.rs @@ -1,13 +1,12 @@ #![cfg(feature = "nix-expr-c")] #![cfg(test)] -use std::{ - ffi::CString, - sync::atomic::{AtomicU32, Ordering}, -}; +use std::ffi::CString; +use std::sync::atomic::{AtomicU32, Ordering}; + +use serial_test::serial; use nixide_sys::*; -use serial_test::serial; #[derive(Debug)] struct TestPrimOpData { @@ -18,10 +17,10 @@ struct TestPrimOpData { // Simple PrimOp that adds 1 to an integer argument unsafe extern "C" fn add_one_primop( user_data: *mut ::std::os::raw::c_void, - context: *mut nix_c_context, + context: *mut NixCContext, state: *mut EvalState, - args: *mut *mut nix_value, - ret: *mut nix_value, + args: *mut *mut NixValue, + ret: *mut NixValue, ) { if user_data.is_null() || context.is_null() @@ -32,7 +31,7 @@ unsafe extern "C" fn add_one_primop( let _ = unsafe { nix_set_err_msg( context, - nix_err_NIX_ERR_UNKNOWN, + NixErr::Unknown, b"Null pointer in add_one_primop\0".as_ptr() as *const _, ) }; @@ -48,7 +47,7 @@ unsafe extern "C" fn add_one_primop( let _ = unsafe { nix_set_err_msg( context, - nix_err_NIX_ERR_UNKNOWN, + NixErr::Unknown, b"Missing argument in add_one_primop\0".as_ptr() as *const _, ) }; @@ -56,16 +55,16 @@ unsafe extern "C" fn add_one_primop( } // Force evaluation of argument - if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK { + if unsafe { nix_value_force(context, state, arg) } != NixErr::Ok { return; } // Check if argument is integer - if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_INT { + if unsafe { nix_get_type(context, arg) } != ValueType::Int { let _ = unsafe { nix_set_err_msg( context, - nix_err_NIX_ERR_UNKNOWN, + NixErr::Unknown, b"Expected integer argument in add_one_primop\0".as_ptr() as *const _, ) }; @@ -83,10 +82,10 @@ unsafe extern "C" fn add_one_primop( // PrimOp that returns a constant string unsafe extern "C" fn hello_world_primop( _user_data: *mut ::std::os::raw::c_void, - context: *mut nix_c_context, + context: *mut NixCContext, _state: *mut EvalState, - _args: *mut *mut nix_value, - ret: *mut nix_value, + _args: *mut *mut NixValue, + ret: *mut NixValue, ) { let hello = CString::new("Hello from Rust PrimOp!").unwrap(); let _ = unsafe { nix_init_string(context, ret, hello.as_ptr()) }; @@ -95,10 +94,10 @@ unsafe extern "C" fn hello_world_primop( // PrimOp that takes multiple arguments and concatenates them unsafe extern "C" fn concat_strings_primop( _user_data: *mut ::std::os::raw::c_void, - context: *mut nix_c_context, + context: *mut NixCContext, state: *mut EvalState, - args: *mut *mut nix_value, - ret: *mut nix_value, + args: *mut *mut NixValue, + ret: *mut NixValue, ) { if context.is_null() || state.is_null() || args.is_null() || ret.is_null() { return; @@ -113,7 +112,7 @@ unsafe extern "C" fn concat_strings_primop( let _ = unsafe { nix_set_err_msg( context, - nix_err_NIX_ERR_UNKNOWN, + NixErr::Unknown, b"Missing argument in concat_strings_primop\0".as_ptr() as *const _, ) }; @@ -121,15 +120,15 @@ unsafe extern "C" fn concat_strings_primop( } // Force evaluation - if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK { + if unsafe { nix_value_force(context, state, arg) } != NixErr::Ok { return; } // Check if it's a string - if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_STRING { + if unsafe { nix_get_type(context, arg) } != ValueType::String { let _ = unsafe { static ITEMS: &[u8] = b"Expected string argument in concat_strings_primop\0"; - nix_set_err_msg(context, nix_err_NIX_ERR_UNKNOWN, ITEMS.as_ptr() as *const _) + nix_set_err_msg(context, NixErr::Unknown, ITEMS.as_ptr() as *const _) }; return; } @@ -168,13 +167,13 @@ fn primop_allocation_and_registration() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -183,7 +182,7 @@ fn primop_allocation_and_registration() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -220,7 +219,7 @@ fn primop_allocation_and_registration() { let register_err = nix_register_primop(ctx, primop); // Registration may fail in some environments, but allocation should work assert!( - register_err == nix_err_NIX_OK || register_err == nix_err_NIX_ERR_UNKNOWN, + register_err == NixErr::Ok || register_err == NixErr::Unknown, "Unexpected error code: {register_err}" ); @@ -229,7 +228,7 @@ fn primop_allocation_and_registration() { assert!(!primop_value.is_null()); let init_err = nix_init_primop(ctx, primop_value, primop); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Clean up value nix_value_decref(ctx, primop_value); @@ -252,13 +251,13 @@ fn primop_function_call() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -267,7 +266,7 @@ fn primop_function_call() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -300,21 +299,21 @@ fn primop_function_call() { assert!(!primop_value.is_null()); let init_err = nix_init_primop(ctx, primop_value, hello_primop); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Call the PrimOp (no arguments) let result = nix_alloc_value(ctx, state); assert!(!result.is_null()); let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result); - if call_err == nix_err_NIX_OK { + if call_err == NixErr::Ok { // Force the result let force_err = nix_value_force(ctx, state, result); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); // Check if result is a string let result_type = nix_get_type(ctx, result); - if result_type == ValueType_NIX_TYPE_STRING { + if result_type == ValueType::String { // Get string value unsafe extern "C" fn string_callback( start: *const ::std::os::raw::c_char, @@ -337,10 +336,12 @@ fn primop_function_call() { ); // Verify we got the expected string - assert!(string_result - .as_deref() - .unwrap_or("") - .contains("Hello from Rust")); + assert!( + string_result + .as_deref() + .unwrap_or("") + .contains("Hello from Rust") + ); } } @@ -365,13 +366,13 @@ fn primop_with_arguments() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -380,7 +381,7 @@ fn primop_with_arguments() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -417,28 +418,28 @@ fn primop_with_arguments() { assert!(!primop_value.is_null()); let init_err = nix_init_primop(ctx, primop_value, add_primop); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Create an integer argument let arg_value = nix_alloc_value(ctx, state); assert!(!arg_value.is_null()); let init_arg_err = nix_init_int(ctx, arg_value, 42); - assert_eq!(init_arg_err, nix_err_NIX_OK); + assert_eq!(init_arg_err, NixErr::Ok); // Call the PrimOp with the argument let result = nix_alloc_value(ctx, state); assert!(!result.is_null()); let call_err = nix_value_call(ctx, state, primop_value, arg_value, result); - if call_err == nix_err_NIX_OK { + if call_err == NixErr::Ok { // Force the result let force_err = nix_value_force(ctx, state, result); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); // Check if result is an integer let result_type = nix_get_type(ctx, result); - if result_type == ValueType_NIX_TYPE_INT { + if result_type == ValueType::Int { let result_value = nix_get_int(ctx, result); assert_eq!(result_value, 43); // 42 + 1 @@ -471,13 +472,13 @@ fn primop_multi_argument() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -486,7 +487,7 @@ fn primop_multi_argument() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); @@ -516,7 +517,7 @@ fn primop_multi_argument() { assert!(!primop_value.is_null()); let init_err = nix_init_primop(ctx, primop_value, concat_primop); - assert_eq!(init_err, nix_err_NIX_OK); + assert_eq!(init_err, NixErr::Ok); // Create string arguments let arg1 = nix_alloc_value(ctx, state); @@ -528,8 +529,8 @@ fn primop_multi_argument() { let init_arg1_err = nix_init_string(ctx, arg1, hello_cstr.as_ptr()); let init_arg2_err = nix_init_string(ctx, arg2, world_cstr.as_ptr()); - assert_eq!(init_arg1_err, nix_err_NIX_OK); - assert_eq!(init_arg2_err, nix_err_NIX_OK); + assert_eq!(init_arg1_err, NixErr::Ok); + assert_eq!(init_arg2_err, NixErr::Ok); // Test multi-argument call using nix_value_call_multi let mut args = [arg1, arg2]; @@ -538,14 +539,14 @@ fn primop_multi_argument() { let call_err = nix_value_call_multi(ctx, state, primop_value, 2, args.as_mut_ptr(), result); - if call_err == nix_err_NIX_OK { + if call_err == NixErr::Ok { // Force the result let force_err = nix_value_force(ctx, state, result); - assert_eq!(force_err, nix_err_NIX_OK); + assert_eq!(force_err, NixErr::Ok); // Check if result is a string let result_type = nix_get_type(ctx, result); - if result_type == ValueType_NIX_TYPE_STRING { + if result_type == ValueType::String { unsafe extern "C" fn string_callback( start: *const ::std::os::raw::c_char, n: ::std::os::raw::c_uint, @@ -592,13 +593,13 @@ fn primop_error_handling() { assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let err = nix_libexpr_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -607,7 +608,7 @@ fn primop_error_handling() { assert!(!builder.is_null()); let load_err = nix_eval_state_builder_load(ctx, builder); - assert_eq!(load_err, nix_err_NIX_OK); + assert_eq!(load_err, NixErr::Ok); let state = nix_eval_state_build(ctx, builder); assert!(!state.is_null()); diff --git a/nixide-sys/tests/store.rs b/nixide-sys/tests/store.rs index b1c8171..1e85322 100644 --- a/nixide-sys/tests/store.rs +++ b/nixide-sys/tests/store.rs @@ -1,10 +1,12 @@ #![cfg(feature = "nix-store-c")] #![cfg(test)] -use std::{ffi::CString, ptr}; +use std::ffi::CString; +use std::ptr; + +use serial_test::serial; use nixide_sys::*; -use serial_test::serial; #[test] #[serial] @@ -13,7 +15,7 @@ fn libstore_init_and_open_free() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); // Open the default store (NULL URI, NULL params) let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); @@ -32,7 +34,7 @@ fn parse_and_clone_free_store_path() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); @@ -74,14 +76,14 @@ fn store_get_uri_and_storedir() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); assert!(!store.is_null()); let mut uri: Option = None; let res = nix_store_get_uri(ctx, store, Some(string_callback), (&raw mut uri).cast()); - assert_eq!(res, nix_err_NIX_OK); + assert_eq!(res, NixErr::Ok); assert!(uri.is_some()); let mut storedir: Option = None; @@ -91,7 +93,7 @@ fn store_get_uri_and_storedir() { Some(string_callback), (&raw mut storedir).cast(), ); - assert_eq!(res, nix_err_NIX_OK); + assert_eq!(res, NixErr::Ok); assert!(storedir.is_some()); nix_store_free(store); @@ -106,7 +108,7 @@ fn libstore_init_no_load_config() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init_no_load_config(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); nix_c_context_free(ctx); } } @@ -129,7 +131,7 @@ fn store_is_valid_path_and_real_path() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -150,7 +152,7 @@ fn store_is_valid_path_and_real_path() { (&raw mut real_path).cast(), ); // May fail, but should not crash - assert!(res == nix_err_NIX_OK || res == nix_err_NIX_ERR_UNKNOWN); + assert!(res == NixErr::Ok || res == NixErr::Unknown); nix_store_path_free(store_path); } @@ -177,7 +179,7 @@ fn store_path_name() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -215,7 +217,7 @@ fn store_get_version() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); @@ -223,7 +225,7 @@ fn store_get_version() { let mut version: Option = None; let res = nix_store_get_version(ctx, store, Some(string_callback), (&raw mut version).cast()); - assert_eq!(res, nix_err_NIX_OK); + assert_eq!(res, NixErr::Ok); // Version may be empty for dummy stores, but should not crash assert!(version.is_some()); @@ -249,7 +251,7 @@ fn store_realise_and_copy_closure() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libstore_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); diff --git a/nixide-sys/tests/util.rs b/nixide-sys/tests/util.rs index 038d30b..5abfbf7 100644 --- a/nixide-sys/tests/util.rs +++ b/nixide-sys/tests/util.rs @@ -1,10 +1,12 @@ +#![cfg(feature = "nix-util-c")] #![cfg(test)] use std::ffi::{CStr, CString}; -use nixide_sys::*; use serial_test::serial; +use nixide_sys::*; + #[test] #[serial] fn context_create_and_free() { @@ -22,7 +24,7 @@ fn libutil_init() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); nix_c_context_free(ctx); } } @@ -60,7 +62,7 @@ fn setting_set_and_get() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); // Set a setting (use a dummy/extra setting to avoid breaking global config) let key = CString::new("extra-test-setting").unwrap(); @@ -68,7 +70,7 @@ fn setting_set_and_get() { let set_err = nix_setting_set(ctx, key.as_ptr(), value.as_ptr()); // Setting may not exist, but should not crash assert!( - set_err == nix_err_NIX_OK || set_err == nix_err_NIX_ERR_KEY, + set_err == NixErr::Ok || set_err == NixErr::Key, "Unexpected error code: {set_err}" ); @@ -81,11 +83,11 @@ fn setting_set_and_get() { (&raw mut got).cast(), ); assert!( - get_err == nix_err_NIX_OK || get_err == nix_err_NIX_ERR_KEY, + get_err == NixErr::Ok || get_err == NixErr::Key, "Unexpected error code: {get_err}" ); // If OK, we should have gotten a value - if get_err == nix_err_NIX_OK { + if get_err == NixErr::Ok { assert_eq!(got.as_deref(), Some("test-value")); } @@ -111,16 +113,16 @@ fn error_handling_apis() { let ctx = nix_c_context_create(); assert!(!ctx.is_null()); let err = nix_libutil_init(ctx); - assert_eq!(err, nix_err_NIX_OK); + assert_eq!(err, NixErr::Ok); // Set an error message let msg = CString::new("custom error message").unwrap(); - let set_err = nix_set_err_msg(ctx, nix_err_NIX_ERR_UNKNOWN, msg.as_ptr()); - assert_eq!(set_err, nix_err_NIX_ERR_UNKNOWN); + let set_err = nix_set_err_msg(ctx, NixErr::Unknown, msg.as_ptr()); + assert_eq!(set_err, NixErr::Unknown); // Get error code let code = nix_err_code(ctx); - assert_eq!(code, nix_err_NIX_ERR_UNKNOWN); + assert_eq!(code, NixErr::Unknown); // Get error message let mut len: std::os::raw::c_uint = 0; @@ -145,7 +147,7 @@ fn error_handling_apis() { // Clear error nix_clear_err(ctx); let code_after_clear = nix_err_code(ctx); - assert_eq!(code_after_clear, nix_err_NIX_OK); + assert_eq!(code_after_clear, NixErr::Ok); nix_c_context_free(ctx); } diff --git a/nixide/src/errors/context.rs b/nixide/src/errors/context.rs index 786daec..9056d82 100644 --- a/nixide/src/errors/context.rs +++ b/nixide/src/errors/context.rs @@ -57,42 +57,29 @@ use crate::util::wrappers::AsInnerPtr; /// }; /// ``` /// -/// The [sys::nix_c_context] struct is laid out so that it can also be -/// cast to a [sys::nix_err] to inspect directly: +/// The [NixCContext] struct is laid out so that it can also be +/// cast to a [sys::NixErr] to inspect directly: /// ```c /// assert(*(nix_err*)ctx == NIX_OK); /// ``` /// pub(crate) struct ErrorContext { - inner: NonNull, + inner: NonNull, } -// impl Clone for ErrorContext { -// 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 } -// } -// } - -impl AsInnerPtr for ErrorContext { +impl AsInnerPtr for ErrorContext { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_c_context { + unsafe fn as_ptr(&self) -> *mut sys::NixCContext { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_c_context { + unsafe fn as_ref(&self) -> &sys::NixCContext { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_c_context { + unsafe fn as_mut(&mut self) -> &mut sys::NixCContext { unsafe { self.inner.as_mut() } } } @@ -100,11 +87,11 @@ impl AsInnerPtr for ErrorContext { impl Into> for &ErrorContext { /// # Panics /// - /// This function will panic in the event that `context.get_err() == Some(err) && err == sys::nix_err_NIX_OK` - /// since `nixide::ErrorContext::get_err` is expected to return `None` to indicate `sys::nix_err_NIX_OK`. + /// This function will panic in the event that `context.get_err() == Some(err) && err == sys::NixErr::NIX_OK` + /// since `nixide::ErrorContext::get_err` is expected to return `None` to indicate `sys::NixErr::NIX_OK`. /// - /// This function will panic in the event that `value != sys::nix_err_NIX_OK` - /// but that `context.get_code() == sys::nix_err_NIX_OK` + /// This function will panic in the event that `value != sys::NixErr::NIX_OK` + /// but that `context.get_code() == sys::NixErr::NIX_OK` /// fn into(self) -> NixideResult<()> { let inner = match self.get_err() { @@ -117,11 +104,11 @@ impl Into> for &ErrorContext { }; let err = match inner { - sys::nix_err_NIX_OK => unreachable!(), + sys::NixErr::Ok => unreachable!(), - sys::nix_err_NIX_ERR_OVERFLOW => NixError::Overflow, - sys::nix_err_NIX_ERR_KEY => NixError::KeyNotFound(None), - sys::nix_err_NIX_ERR_NIX_ERROR => NixError::ExprEval { + sys::NixErr::Overflow => NixError::Overflow, + sys::NixErr::Key => NixError::KeyNotFound(None), + sys::NixErr::NixError => NixError::ExprEval { name: self .get_nix_err_name() .unwrap_or_else(|| panic_issue_call_failed!()), @@ -131,7 +118,7 @@ impl Into> for &ErrorContext { .unwrap_or_else(|| panic_issue_call_failed!()), }, - sys::nix_err_NIX_ERR_UNKNOWN => NixError::Unknown, + sys::NixErr::Unknown => NixError::Unknown, err => NixError::Undocumented(err), }; @@ -145,13 +132,13 @@ impl ErrorContext { /// # Errors /// /// Returns an error if no memory can be allocated for - /// the underlying [sys::nix_c_context] struct. + /// the underlying [NixCContext] struct. /// pub fn new() -> Self { match NonNull::new(unsafe { sys::nix_c_context_create() }) { Some(inner) => ErrorContext { inner }, None => panic!( - "[nixide] CRITICAL FAILURE: Out-Of-Memory condition reached - `sys::nix_c_context_create` allocation failed!" + "[nixide] CRITICAL FAILURE: Out-Of-Memory condition reached - `NixCContext_create` allocation failed!" ), } } @@ -216,12 +203,12 @@ impl ErrorContext { Ok(()) } - /// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise. + /// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise. /// /// # Nix C++ API Internals /// /// ```cpp - /// nix_err nix_err_code(const nix_c_context * read_context) + /// nix_err nix_err::code(const nix_c_context * read_context) /// { /// return read_context->last_err_code; /// } @@ -229,19 +216,19 @@ impl ErrorContext { /// /// This function **never fails**. /// - fn get_err(&self) -> Option { + fn get_err(&self) -> Option { match unsafe { sys::nix_err_code(self.as_ptr()) } { - sys::nix_err_NIX_OK => None, + sys::NixErr::Ok => None, err => Some(err), } } - /// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise. + /// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise. /// /// # Nix C++ API Internals /// /// ```cpp - /// const char * nix_err_msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n) + /// const char * nix_err::msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n) /// { /// if (context) /// context->last_err_code = NIX_OK; @@ -250,21 +237,21 @@ impl ErrorContext { /// *n = read_context->last_err->size(); /// return read_context->last_err->c_str(); /// } - /// nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message"); + /// nix_set_err_msg(context, NIX_ERR::UNKNOWN, "No error message"); /// return nullptr; /// } /// ``` /// /// # Note /// - /// On failure [sys::nix_err_name] does the following if the error - /// has the error code [sys::nix_err_NIX_OK]: + /// On failure [sys::NixErr::name] does the following if the error + /// has the error code [sys::NixErr::NIX_OK]: /// ```cpp - /// nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message"); + /// nix_set_err_msg(context, NIX_ERR::UNKNOWN, "No error message"); /// return nullptr; /// ``` /// Hence we can just test whether the returned pointer is a `NULL` pointer, - /// and avoid passing in a [sys::nix_c_context] struct. + /// and avoid passing in a [NixCContext] struct. /// fn get_msg(&self) -> Option { // NOTE: an Err here only occurs when `self.get_code() == Ok(())` @@ -281,13 +268,13 @@ impl ErrorContext { } } - /// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise. + /// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise. /// /// # Nix C++ API Internals /// /// ```cpp - /// // NOTE(nixide): the implementation of `nix_err_info_msg` is identical to `nix_err_name` - /// nix_err nix_err_info_msg( + /// // NOTE(nixide): the implementation of `nix_err::info_msg` is identical to `nix_err::name` + /// nix_err nix_err::info_msg( /// nix_c_context * context, /// const nix_c_context * read_context, /// nix_get_string_callback callback, @@ -295,16 +282,16 @@ impl ErrorContext { /// { /// if (context) /// context->last_err_code = NIX_OK; - /// if (read_context->last_err_code != NIX_ERR_NIX_ERROR) { + /// if (read_context->last_err_code != NIX_ERR::NIX_ERROR) { /// // NOTE(nixide): `nix_set_err_msg` throws a `nix::Error` exception if `context == nullptr` - /// return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error"); + /// return nix_set_err_msg(context, NIX_ERR::UNKNOWN, "Last error was not a nix error"); /// } /// // NOTE(nixide): `call_nix_get_string_callback` always returns `NIX_OK` /// return call_nix_get_string_callback(read_context->info->msg.str(), callback, user_data); /// } /// ``` /// - /// `nix_err_info_msg` accepts two `nix_c_context*`: + /// `nix_err::info_msg` accepts two `nix_c_context*`: /// * `nix_c_context* context` - errors from the function call are logged here /// * `const nix_c_context* read_context` - the context to read `info_msg` from /// @@ -333,13 +320,13 @@ impl ErrorContext { .ok() } - /// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise. + /// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise. /// /// # Nix C++ API Internals /// /// ```cpp - /// // NOTE(nixide): the implementation of `nix_err_info_msg` is identical to `nix_err_name` - /// nix_err nix_err_info_msg( + /// // NOTE(nixide): the implementation of `nix_err::info_msg` is identical to `nix_err::name` + /// nix_err nix_err::info_msg( /// nix_c_context * context, /// const nix_c_context * read_context, /// nix_get_string_callback callback, @@ -347,16 +334,16 @@ impl ErrorContext { /// { /// if (context) /// context->last_err_code = NIX_OK; - /// if (read_context->last_err_code != NIX_ERR_NIX_ERROR) { + /// if (read_context->last_err_code != NIX_ERR::NIX_ERROR) { /// // NOTE(nixide): `nix_set_err_msg` throws a `nix::Error` exception if `context == nullptr` - /// return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error"); + /// return nix_set_err_msg(context, NIX_ERR::UNKNOWN, "Last error was not a nix error"); /// } /// // NOTE(nixide): `call_nix_get_string_callback` always returns `NIX_OK` /// return call_nix_get_string_callback(read_context->info->msg.str(), callback, user_data); /// } /// ``` /// - /// `nix_err_info_msg` accepts two `nix_c_context*`: + /// `nix_err::info_msg` accepts two `nix_c_context*`: /// * `nix_c_context* context` - errors from the function call are logged here /// * `const nix_c_context* read_context` - the context to read `info_msg` from /// diff --git a/nixide/src/errors/error.rs b/nixide/src/errors/error.rs index 29696f1..b0bb66a 100644 --- a/nixide/src/errors/error.rs +++ b/nixide/src/errors/error.rs @@ -12,7 +12,7 @@ pub enum NixideError { /// that is instead mapped to [NixError::ExprEval] NixError { trace: String, - inner: sys::nix_err, + inner: sys::NixErr, err: NixError, msg: String, }, @@ -84,9 +84,7 @@ pub(crate) use new_nixide_error; #[allow(unused_macros)] macro_rules! retrace_nixide_error { - ($x:expr) => {{ - crate::errors::new_nixide_error!($x.err) - }}; + ($x:expr) => {{ crate::errors::new_nixide_error!($x.err) }}; } pub(crate) use retrace_nixide_error; @@ -102,15 +100,15 @@ impl Display for NixideError { msg, } => { write!(f, "[nixide ~ {trace}]{err} (nix_err={inner}): {msg}") - } + }, NixideError::StringNulByte { trace } => { write!(f, "[nixide ~ {trace}] Got premature `\\0` (NUL) byte") - } + }, NixideError::StringNotUtf8 { trace } => { write!(f, "[nixide ~ {trace}] Expected UTF-8 encoded string") - } + }, NixideError::NullPtr { trace } => write!(f, "[nixide ~ {trace}] Got null pointer"), @@ -123,7 +121,7 @@ impl Display for NixideError { f, "[nixide ~ {trace}] Invalid argument `{name}`: reason \"{reason}\"" ) - } + }, NixideError::InvalidType { trace, diff --git a/nixide/src/errors/nix_error.rs b/nixide/src/errors/nix_error.rs index 1d67312..c239e5f 100644 --- a/nixide/src/errors/nix_error.rs +++ b/nixide/src/errors/nix_error.rs @@ -93,15 +93,18 @@ pub enum NixError { /// /// [NixError::Undocumented] has no equivalent in the `libnix` api. /// This is solely a language difference between C++ and Rust, since - /// [sys::nix_err] is defined over the *"continuous" (not realy)* + /// [sys::NixErr] is defined over the *"continuous" (not realy)* /// type [std::os::raw::c_int]. - Undocumented(sys::nix_err), + Undocumented(sys::NixErr), } impl Display for NixError { fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { match self { - NixError::ExprEval { name, info_msg } => write!(f, "[libnix] NixExpr evaluation failed [name=\"{name}\", info_msg=\"{info_msg}\"]"), + NixError::ExprEval { name, info_msg } => write!( + f, + "[libnix] NixExpr evaluation failed [name=\"{name}\", info_msg=\"{info_msg}\"]" + ), NixError::KeyNotFound(Some(key)) => write!(f, "[libnix] Key not found \"{key}\""), NixError::KeyNotFound(None) => write!(f, "[libnix] Key not found"), NixError::Overflow => write!(f, "[libnix] Overflow error"), @@ -115,15 +118,15 @@ impl Display for NixError { } impl NixError { - pub fn err_code(&self) -> sys::nix_err { + pub fn err_code(&self) -> sys::NixErr { match self { - NixError::Overflow => sys::nix_err_NIX_ERR_OVERFLOW, - NixError::KeyNotFound(_) => sys::nix_err_NIX_ERR_NIX_ERROR, + NixError::Overflow => sys::NixErr::Overflow, + NixError::KeyNotFound(_) => sys::NixErr::Key, NixError::ExprEval { name: _, info_msg: _, - } => sys::nix_err_NIX_ERR_NIX_ERROR, - NixError::Unknown => sys::nix_err_NIX_ERR_UNKNOWN, + } => sys::NixErr::NixError, + NixError::Unknown => sys::NixErr::NixError, NixError::Undocumented(err) => err.clone(), } } diff --git a/nixide/src/expr/eval_state_builder.rs b/nixide/src/expr/eval_state_builder.rs index 2ae0056..e1265db 100644 --- a/nixide/src/expr/eval_state_builder.rs +++ b/nixide/src/expr/eval_state_builder.rs @@ -18,23 +18,23 @@ use crate::util::{panic_issue_call_failed, wrap}; /// the evaluation state. /// pub struct EvalStateBuilder { - inner: Rc>>, + inner: Rc>>, store: Rc>, } -impl AsInnerPtr for EvalStateBuilder { +impl AsInnerPtr for EvalStateBuilder { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_eval_state_builder { + unsafe fn as_ptr(&self) -> *mut sys::NixEvalStateBuilder { self.inner.borrow().as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_eval_state_builder { + unsafe fn as_ref(&self) -> &sys::NixEvalStateBuilder { unsafe { self.inner.borrow().as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_eval_state_builder { + unsafe fn as_mut(&mut self) -> &mut sys::NixEvalStateBuilder { unsafe { self.inner.borrow_mut().as_mut() } } } diff --git a/nixide/src/expr/realised_string.rs b/nixide/src/expr/realised_string.rs index 0d41b6f..8cf08a4 100644 --- a/nixide/src/expr/realised_string.rs +++ b/nixide/src/expr/realised_string.rs @@ -12,24 +12,24 @@ use crate::{EvalState, NixideResult, StorePath}; use crate::{Store, sys}; pub struct RealisedString<'a> { - inner: RefCell>, + inner: RefCell>, pub path: StorePath, pub children: LazyArray StorePath + 'a>>, } -impl<'a> AsInnerPtr for RealisedString<'a> { +impl<'a> AsInnerPtr for RealisedString<'a> { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_realised_string { + unsafe fn as_ptr(&self) -> *mut sys::NixRealisedString { self.inner.borrow().as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_realised_string { + unsafe fn as_ref(&self) -> &sys::NixRealisedString { unsafe { self.inner.borrow().as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_realised_string { + unsafe fn as_mut(&mut self) -> &mut sys::NixRealisedString { unsafe { self.inner.borrow_mut().as_mut() } } } @@ -82,7 +82,7 @@ impl<'a> RealisedString<'a> { }) } - fn parse_path(realised_string: *mut sys::nix_realised_string, store: &Store) -> StorePath { + fn parse_path(realised_string: *mut sys::NixRealisedString, 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) }; diff --git a/nixide/src/expr/values/attrs.rs b/nixide/src/expr/values/attrs.rs index 0213e54..c6c87b8 100644 --- a/nixide/src/expr/values/attrs.rs +++ b/nixide/src/expr/values/attrs.rs @@ -12,7 +12,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixAttrs { - inner: NonNull, + inner: NonNull, state: Rc>>, len: u32, } @@ -55,19 +55,19 @@ impl Debug for NixAttrs { } } -impl AsInnerPtr for NixAttrs { +impl AsInnerPtr for NixAttrs { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -75,10 +75,10 @@ impl AsInnerPtr for NixAttrs { impl NixValue for NixAttrs { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_ATTRS + sys::ValueType::Attrs } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let len = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_get_attrs_size(ctx.as_ptr(), inner.as_ptr()) }) diff --git a/nixide/src/expr/values/bool.rs b/nixide/src/expr/values/bool.rs index 54fcade..f5a97e6 100644 --- a/nixide/src/expr/values/bool.rs +++ b/nixide/src/expr/values/bool.rs @@ -11,7 +11,7 @@ use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; pub struct NixBool { - inner: NonNull, + inner: NonNull, state: Rc>>, value: bool, } @@ -54,19 +54,19 @@ impl Debug for NixBool { } } -impl AsInnerPtr for NixBool { +impl AsInnerPtr for NixBool { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -74,10 +74,10 @@ impl AsInnerPtr for NixBool { impl NixValue for NixBool { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_BOOL + sys::ValueType::Bool } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_get_bool(ctx.as_ptr(), inner.as_ptr()) }) diff --git a/nixide/src/expr/values/float.rs b/nixide/src/expr/values/float.rs index 3b0be68..9016a66 100644 --- a/nixide/src/expr/values/float.rs +++ b/nixide/src/expr/values/float.rs @@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixFloat { - inner: NonNull, + inner: NonNull, state: Rc>>, value: f64, } @@ -53,19 +53,19 @@ impl Debug for NixFloat { } } -impl AsInnerPtr for NixFloat { +impl AsInnerPtr for NixFloat { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -73,10 +73,10 @@ impl AsInnerPtr for NixFloat { impl NixValue for NixFloat { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_FLOAT + sys::ValueType::Float } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_get_float(ctx.as_ptr(), inner.as_ptr()) }) diff --git a/nixide/src/expr/values/function.rs b/nixide/src/expr/values/function.rs index 5ed9a18..a3d0e2a 100644 --- a/nixide/src/expr/values/function.rs +++ b/nixide/src/expr/values/function.rs @@ -11,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixFunction { - inner: NonNull, + inner: NonNull, state: Rc>>, } @@ -52,19 +52,19 @@ impl Debug for NixFunction { } } -impl AsInnerPtr for NixFunction { +impl AsInnerPtr for NixFunction { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -72,10 +72,10 @@ impl AsInnerPtr for NixFunction { impl NixValue for NixFunction { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_FUNCTION + sys::ValueType::Function } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { Self { inner, state } } } diff --git a/nixide/src/expr/values/int.rs b/nixide/src/expr/values/int.rs index 815edef..e98ecd1 100644 --- a/nixide/src/expr/values/int.rs +++ b/nixide/src/expr/values/int.rs @@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixInt { - inner: NonNull, + inner: NonNull, state: Rc>>, value: i64, } @@ -53,19 +53,19 @@ impl Debug for NixInt { } } -impl AsInnerPtr for NixInt { +impl AsInnerPtr for NixInt { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -73,10 +73,10 @@ impl AsInnerPtr for NixInt { impl NixValue for NixInt { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_INT + sys::ValueType::Int } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_get_int(ctx.as_ptr(), inner.as_ptr()) }) diff --git a/nixide/src/expr/values/list.rs b/nixide/src/expr/values/list.rs index 7172f8b..cb320de 100644 --- a/nixide/src/expr/values/list.rs +++ b/nixide/src/expr/values/list.rs @@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixList { - inner: NonNull, + inner: NonNull, state: Rc>>, } @@ -51,19 +51,19 @@ impl Debug for NixList { } } -impl AsInnerPtr for NixList { +impl AsInnerPtr for NixList { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -71,10 +71,10 @@ impl AsInnerPtr for NixList { impl NixValue for NixList { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_LIST + sys::ValueType::List } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { Self { inner, state } } } diff --git a/nixide/src/expr/values/mod.rs b/nixide/src/expr/values/mod.rs index a06edde..832ac10 100644 --- a/nixide/src/expr/values/mod.rs +++ b/nixide/src/expr/values/mod.rs @@ -30,21 +30,16 @@ use std::rc::Rc; use crate::errors::ErrorContext; use crate::sys; -use crate::sys::{ - ValueType_NIX_TYPE_ATTRS, ValueType_NIX_TYPE_BOOL, ValueType_NIX_TYPE_EXTERNAL, - ValueType_NIX_TYPE_FLOAT, ValueType_NIX_TYPE_FUNCTION, ValueType_NIX_TYPE_INT, - ValueType_NIX_TYPE_LIST, ValueType_NIX_TYPE_NULL, ValueType_NIX_TYPE_PATH, - ValueType_NIX_TYPE_STRING, ValueType_NIX_TYPE_THUNK, -}; +use crate::sys::ValueType; use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; -pub trait NixValue: Clone + Drop + Display + Debug + AsInnerPtr { +pub trait NixValue: Clone + Drop + Display + Debug + AsInnerPtr { /// TODO fn type_id(&self) -> sys::ValueType; /// TODO - fn from(inner: NonNull, state: Rc>>) -> Self; + fn from(inner: NonNull, state: Rc>>) -> Self; } /// A Nix value @@ -110,18 +105,8 @@ pub enum Value { // Failed(NixFailed), } -impl - From<( - NonNull, - Rc>>, - )> for Value -{ - fn from( - value: ( - NonNull, - Rc>>, - ), - ) -> Self { +impl From<(NonNull, Rc>>)> for Value { + fn from(value: (NonNull, Rc>>)) -> Self { let (inner, state) = value; wrap::nix_fn!(|ctx: &ErrorContext| unsafe { @@ -136,22 +121,20 @@ impl #[allow(non_upper_case_globals)] match type_id { - ValueType_NIX_TYPE_THUNK => Value::Thunk(::from(inner, state)), - ValueType_NIX_TYPE_INT => Value::Int(::from(inner, state)), - ValueType_NIX_TYPE_FLOAT => Value::Float(::from(inner, state)), - ValueType_NIX_TYPE_BOOL => Value::Bool(::from(inner, state)), - ValueType_NIX_TYPE_STRING => Value::String(::from(inner, state)), - ValueType_NIX_TYPE_PATH => Value::Path(::from(inner, state)), - ValueType_NIX_TYPE_NULL => Value::Null(::from(inner, state)), - ValueType_NIX_TYPE_ATTRS => Value::Attrs(::from(inner, state)), - ValueType_NIX_TYPE_LIST => Value::List(::from(inner, state)), - ValueType_NIX_TYPE_FUNCTION => { - Value::Function(::from(inner, state)) - }, - // ValueType_NIX_TYPE_EXTERNAL => { + ValueType::Thunk => Value::Thunk(::from(inner, state)), + ValueType::Int => Value::Int(::from(inner, state)), + ValueType::Float => Value::Float(::from(inner, state)), + ValueType::Bool => Value::Bool(::from(inner, state)), + ValueType::String => Value::String(::from(inner, state)), + ValueType::Path => Value::Path(::from(inner, state)), + ValueType::Null => Value::Null(::from(inner, state)), + ValueType::Attrs => Value::Attrs(::from(inner, state)), + ValueType::List => Value::List(::from(inner, state)), + ValueType::Function => Value::Function(::from(inner, state)), + // ValueType::External => { // Value::External(::from(inner, state)) // }, - // ValueType_NIX_TYPE_FAILED => { + // ValueType::Failed => { // Value::Failed(::from(inner, state)) // }, _ => unreachable!(), diff --git a/nixide/src/expr/values/null.rs b/nixide/src/expr/values/null.rs index 46bfe15..18b47b5 100644 --- a/nixide/src/expr/values/null.rs +++ b/nixide/src/expr/values/null.rs @@ -10,7 +10,7 @@ use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; pub struct NixNull { - inner: NonNull, + inner: NonNull, state: Rc>>, } @@ -51,19 +51,19 @@ impl Debug for NixNull { } } -impl AsInnerPtr for NixNull { +impl AsInnerPtr for NixNull { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -71,10 +71,10 @@ impl AsInnerPtr for NixNull { impl NixValue for NixNull { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_NULL + sys::ValueType::Null } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { Self { inner, state } } } diff --git a/nixide/src/expr/values/path.rs b/nixide/src/expr/values/path.rs index f9a49a0..1ccbfcb 100644 --- a/nixide/src/expr/values/path.rs +++ b/nixide/src/expr/values/path.rs @@ -13,7 +13,7 @@ use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; pub struct NixPath { - inner: NonNull, + inner: NonNull, state: Rc>>, value: PathBuf, } @@ -56,19 +56,19 @@ impl Debug for NixPath { } } -impl AsInnerPtr for NixPath { +impl AsInnerPtr for NixPath { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -76,10 +76,10 @@ impl AsInnerPtr for NixPath { impl NixValue for NixPath { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_PATH + sys::ValueType::Path } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe { sys::nix_get_path_string(ctx.as_ptr(), inner.as_ptr()) }) diff --git a/nixide/src/expr/values/string.rs b/nixide/src/expr/values/string.rs index d2582de..c514d45 100644 --- a/nixide/src/expr/values/string.rs +++ b/nixide/src/expr/values/string.rs @@ -12,7 +12,7 @@ use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; pub struct NixString { - inner: NonNull, + inner: NonNull, state: Rc>>, value: String, } @@ -55,19 +55,19 @@ impl Debug for NixString { } } -impl AsInnerPtr for NixString { +impl AsInnerPtr for NixString { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -75,10 +75,10 @@ impl AsInnerPtr for NixString { impl NixValue for NixString { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_STRING + sys::ValueType::String } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { let value = wrap::nix_string_callback!( |callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe { sys::nix_get_string( diff --git a/nixide/src/expr/values/thunk.rs b/nixide/src/expr/values/thunk.rs index 294745e..c84a219 100644 --- a/nixide/src/expr/values/thunk.rs +++ b/nixide/src/expr/values/thunk.rs @@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::util::{panic_issue_call_failed, wrap}; pub struct NixThunk { - inner: NonNull, + inner: NonNull, state: Rc>>, } @@ -51,19 +51,19 @@ impl Debug for NixThunk { } } -impl AsInnerPtr for NixThunk { +impl AsInnerPtr for NixThunk { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_value { + unsafe fn as_ptr(&self) -> *mut sys::NixValue { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_value { + unsafe fn as_ref(&self) -> &sys::NixValue { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_value { + unsafe fn as_mut(&mut self) -> &mut sys::NixValue { unsafe { self.inner.as_mut() } } } @@ -71,10 +71,10 @@ impl AsInnerPtr for NixThunk { impl NixValue for NixThunk { #[inline] fn type_id(&self) -> sys::ValueType { - sys::ValueType_NIX_TYPE_THUNK + sys::ValueType::Thunk } - fn from(inner: NonNull, state: Rc>>) -> Self { + fn from(inner: NonNull, state: Rc>>) -> Self { Self { inner, state } } } diff --git a/nixide/src/flake/fetchers_settings.rs b/nixide/src/flake/fetchers_settings.rs index cf15df2..5f8b31b 100644 --- a/nixide/src/flake/fetchers_settings.rs +++ b/nixide/src/flake/fetchers_settings.rs @@ -7,7 +7,7 @@ use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; pub struct FetchersSettings { - inner: NonNull, + inner: NonNull, } impl FetchersSettings { @@ -41,19 +41,19 @@ impl Drop for FetchersSettings { } } -impl AsInnerPtr for FetchersSettings { +impl AsInnerPtr for FetchersSettings { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_fetchers_settings { + unsafe fn as_ptr(&self) -> *mut sys::NixFetchersSettings { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_fetchers_settings { + unsafe fn as_ref(&self) -> &sys::NixFetchersSettings { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_fetchers_settings { + unsafe fn as_mut(&mut self) -> &mut sys::NixFetchersSettings { unsafe { self.inner.as_mut() } } } diff --git a/nixide/src/flake/flake_lock_flags.rs b/nixide/src/flake/flake_lock_flags.rs index 8b3985a..d471987 100644 --- a/nixide/src/flake/flake_lock_flags.rs +++ b/nixide/src/flake/flake_lock_flags.rs @@ -1,4 +1,3 @@ -use std::ffi::c_void; use std::ptr::NonNull; use super::{FlakeReference, FlakeSettings}; @@ -26,7 +25,7 @@ pub enum FlakeLockMode { /// Parameters that affect the locking of a flake. pub struct FlakeLockFlags { - pub(crate) inner: NonNull, + pub(crate) inner: NonNull, } // impl Clone for FlakeLockFlags { @@ -50,19 +49,19 @@ impl Drop for FlakeLockFlags { } } -impl AsInnerPtr for FlakeLockFlags { +impl AsInnerPtr for FlakeLockFlags { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_flake_lock_flags { + unsafe fn as_ptr(&self) -> *mut sys::NixFlakeLockFlags { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_flake_lock_flags { + unsafe fn as_ref(&self) -> &sys::NixFlakeLockFlags { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_lock_flags { + unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeLockFlags { unsafe { self.inner.as_mut() } } } diff --git a/nixide/src/flake/flake_reference.rs b/nixide/src/flake/flake_reference.rs index 67ddf41..2872578 100644 --- a/nixide/src/flake/flake_reference.rs +++ b/nixide/src/flake/flake_reference.rs @@ -11,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr; // XXX: TODO: rename FlakeReference -> FlakeRef pub struct FlakeReference { - inner: NonNull, + inner: NonNull, fragment: String, } @@ -37,19 +37,19 @@ impl Drop for FlakeReference { } } -impl AsInnerPtr for FlakeReference { +impl AsInnerPtr for FlakeReference { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_flake_reference { + unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_flake_reference { + unsafe fn as_ref(&self) -> &sys::NixFlakeReference { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_reference { + unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeReference { unsafe { self.inner.as_mut() } } } @@ -65,7 +65,7 @@ impl FlakeReference { flags: &FlakeReferenceParseFlags, reference: &str, ) -> Result { - let mut ptr: *mut sys::nix_flake_reference = null_mut(); + let mut ptr: *mut sys::NixFlakeReference = null_mut(); let fragment = wrap::nix_string_callback!( |callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe { sys::nix_flake_reference_and_fragment_from_string( diff --git a/nixide/src/flake/flake_reference_parse_flags.rs b/nixide/src/flake/flake_reference_parse_flags.rs index cddf391..2b47aea 100644 --- a/nixide/src/flake/flake_reference_parse_flags.rs +++ b/nixide/src/flake/flake_reference_parse_flags.rs @@ -1,4 +1,3 @@ -use std::ffi::c_void; use std::os::raw::c_char; use std::ptr::NonNull; @@ -12,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr; /// Parameters for parsing a flake reference. #[derive(Debug)] pub struct FlakeReferenceParseFlags { - inner: NonNull, + inner: NonNull, } // impl Clone for FlakeReferenceParseFlags { @@ -36,19 +35,19 @@ impl Drop for FlakeReferenceParseFlags { } } -impl AsInnerPtr for FlakeReferenceParseFlags { +impl AsInnerPtr for FlakeReferenceParseFlags { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_flake_reference_parse_flags { + unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_flake_reference_parse_flags { + unsafe fn as_ref(&self) -> &sys::NixFlakeReferenceParseFlags { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_reference_parse_flags { + unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeReferenceParseFlags { unsafe { self.inner.as_mut() } } } diff --git a/nixide/src/flake/flake_settings.rs b/nixide/src/flake/flake_settings.rs index 9d11358..e021f4f 100644 --- a/nixide/src/flake/flake_settings.rs +++ b/nixide/src/flake/flake_settings.rs @@ -8,7 +8,7 @@ use crate::util::wrappers::AsInnerPtr; /// Store settings for the flakes feature. pub struct FlakeSettings { - inner: NonNull, + inner: NonNull, } impl Drop for FlakeSettings { @@ -19,19 +19,19 @@ impl Drop for FlakeSettings { } } -impl AsInnerPtr for FlakeSettings { +impl AsInnerPtr for FlakeSettings { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_flake_settings { + unsafe fn as_ptr(&self) -> *mut sys::NixFlakeSettings { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_flake_settings { + unsafe fn as_ref(&self) -> &sys::NixFlakeSettings { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_settings { + unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeSettings { unsafe { self.inner.as_mut() } } } diff --git a/nixide/src/flake/locked_flake.rs b/nixide/src/flake/locked_flake.rs index 4f0237c..4192b8f 100644 --- a/nixide/src/flake/locked_flake.rs +++ b/nixide/src/flake/locked_flake.rs @@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr; use crate::{EvalState, NixideResult, Value}; pub struct LockedFlake { - inner: NonNull, + inner: NonNull, flakeref: FlakeReference, state: EvalState, @@ -45,19 +45,19 @@ impl Drop for LockedFlake { } } -impl AsInnerPtr for LockedFlake { +impl AsInnerPtr for LockedFlake { #[inline] - unsafe fn as_ptr(&self) -> *mut sys::nix_locked_flake { + unsafe fn as_ptr(&self) -> *mut sys::NixLockedFlake { self.inner.as_ptr() } #[inline] - unsafe fn as_ref(&self) -> &sys::nix_locked_flake { + unsafe fn as_ref(&self) -> &sys::NixLockedFlake { unsafe { self.inner.as_ref() } } #[inline] - unsafe fn as_mut(&mut self) -> &mut sys::nix_locked_flake { + unsafe fn as_mut(&mut self) -> &mut sys::NixLockedFlake { unsafe { self.inner.as_mut() } } } diff --git a/nixide/src/verbosity.rs b/nixide/src/verbosity.rs index a740027..a95f55c 100644 --- a/nixide/src/verbosity.rs +++ b/nixide/src/verbosity.rs @@ -1,13 +1,14 @@ use crate::errors::ErrorContext; use crate::sys; use crate::util::wrappers::AsInnerPtr as _; -use crate::util::{panic_issue, panic_issue_call_failed, wrap}; +use crate::util::{panic_issue_call_failed, wrap}; /// Verbosity level /// /// # NOTE /// /// This should be kept in sync with the C++ implementation (nix::Verbosity) +/// #[derive(Debug, Clone, Copy)] pub enum NixVerbosity { Error, @@ -20,28 +21,24 @@ pub enum NixVerbosity { Vomit, } -impl From for NixVerbosity { - fn from(level: sys::nix_verbosity) -> NixVerbosity { +impl From for NixVerbosity { + fn from(level: sys::NixVerbosity) -> NixVerbosity { match level { - sys::nix_verbosity_NIX_LVL_ERROR => NixVerbosity::Error, - sys::nix_verbosity_NIX_LVL_WARN => NixVerbosity::Warn, - sys::nix_verbosity_NIX_LVL_NOTICE => NixVerbosity::Notice, - sys::nix_verbosity_NIX_LVL_INFO => NixVerbosity::Info, - sys::nix_verbosity_NIX_LVL_TALKATIVE => NixVerbosity::Talkative, - sys::nix_verbosity_NIX_LVL_CHATTY => NixVerbosity::Chatty, - sys::nix_verbosity_NIX_LVL_DEBUG => NixVerbosity::Debug, - sys::nix_verbosity_NIX_LVL_VOMIT => NixVerbosity::Vomit, - value => panic_issue!( - "nixide encountered unknown `nix_verbosity` value ({})", - value - ), + sys::NixVerbosity::Error => NixVerbosity::Error, + sys::NixVerbosity::Warn => NixVerbosity::Warn, + sys::NixVerbosity::Notice => NixVerbosity::Notice, + sys::NixVerbosity::Info => NixVerbosity::Info, + sys::NixVerbosity::Talkative => NixVerbosity::Talkative, + sys::NixVerbosity::Chatty => NixVerbosity::Chatty, + sys::NixVerbosity::Debug => NixVerbosity::Debug, + sys::NixVerbosity::Vomit => NixVerbosity::Vomit, } } } -impl Into for NixVerbosity { - fn into(self) -> sys::nix_verbosity { - self as sys::nix_verbosity +impl Into for NixVerbosity { + fn into(self) -> sys::NixVerbosity { + self as sys::NixVerbosity } }