fix

Author: gpwclark

bridge_adapters/src/lisp_adapters/numbers.rs

@@ -4,7 +4,7 @@ use bridge_types::{ErrorStrings, LooseFloat, LooseInt, LooseString};
 use compile_state::state::SloshVm;
 use slvm::float::F56;
 use slvm::value::ValueType;
-use slvm::{to_i56, Value, ValueTypes, I56};
+use slvm::{I56, Value, ValueTypes, to_i56};
 
 impl SlFrom<()> for Value {
     fn sl_from(_value: (), _vm: &mut SloshVm) -> BridgeResult<Self> {

bridge_adapters/src/lisp_adapters/text.rs

@@ -292,33 +292,34 @@ mod tests {
 
         let param = arg_types[0usize];
         match param.handle {
-            bridge_types::TypeHandle::Direct => {
-                match args.get(0usize) {
-                    None => Err(BridgeError::Error(format!(
-                        "{} not given enough arguments, expected at least {} arguments, got {}.",
-                        fn_name,
-                        1usize,
-                        args.len()
-                    ))),
-                    Some(mut arg_0) => match args.get(PARAMS_LEN) {
-                        Some(_)
-                            if PARAMS_LEN == 0
-                                || arg_types[PARAMS_LEN - 1].handle
-                                    != bridge_types::TypeHandle::VarArgs =>
-                        {
-                            let res =
-                            format!("{} given too many arguments, expected at least {} arguments, got {}.",
-                                    fn_name, 1usize, args.len());
-                            Err(BridgeError::Error(res))
-                        }
-                        _ => {
-                            let arg: &mut String = arg_0.sl_as_mut(vm)?;
-                            arg.push_str("0");
-                            Ok(())
-                        }
-                    },
-                }
-            }
+            bridge_types::TypeHandle::Direct => match args.get(0usize) {
+                None => Err(BridgeError::Error(format!(
+                    "{} not given enough arguments, expected at least {} arguments, got {}.",
+                    fn_name,
+                    1usize,
+                    args.len()
+                ))),
+                Some(mut arg_0) => match args.get(PARAMS_LEN) {
+                    Some(_)
+                        if PARAMS_LEN == 0
+                            || arg_types[PARAMS_LEN - 1].handle
+                                != bridge_types::TypeHandle::VarArgs =>
+                    {
+                        let res = format!(
+                            "{} given too many arguments, expected at least {} arguments, got {}.",
+                            fn_name,
+                            1usize,
+                            args.len()
+                        );
+                        Err(BridgeError::Error(res))
+                    }
+                    _ => {
+                        let arg: &mut String = arg_0.sl_as_mut(vm)?;
+                        arg.push_str("0");
+                        Ok(())
+                    }
+                },
+            },
             _ => Err(BridgeError::Error(format!(
                 "{} failed to parse its arguments, internal error.",
                 fn_name

builtins/src/lib.rs

@@ -1,8 +1,8 @@
 extern crate core;
 
+use bridge_adapters::BridgeError;
 use bridge_adapters::add_builtin;
 use bridge_adapters::lisp_adapters::SlFromRef;
-use bridge_adapters::BridgeError;
 use bridge_macros::sl_sh_fn;
 use bridge_types::{KeywordAsString, LooseString};
 use compile_state::state::{SloshVm, SloshVmTrait};

slosh_test_lib/src/docs.rs

@@ -1,8 +1,7 @@
 use crate::docs::legacy as legacy_docs;
 use bridge_adapters::add_builtin;
 use bridge_adapters::lisp_adapters::SlFrom;
-use bridge_adapters::{BridgeResult, BridgeError};
-use bridge_macros::sl_sh_fn;
+use bridge_adapters::{BridgeError, BridgeResult};
 use compile_state::state::{SloshVm, SloshVmTrait};
 use lazy_static::lazy_static;
 use mdbook::book::{Book, Chapter};
@@ -1459,7 +1458,7 @@ fn doc_search(vm: &mut SloshVm, registers: &[Value]) -> VMResult<Value> {
         // Generate vector of doc maps
         let mut result_values = Vec::new();
         for doc in results {
-            match Value::sl_from(doc, vm) {
+            match BridgeError::with_fn(Value::sl_from(doc, vm), "doc-search") {
                 Ok(val) => result_values.push(val),
                 Err(e) => {
                     vm.unpause_gc();