Neovim crashing on errors

[ricardokl]

Hi,

When I try to deserialize data into a Struct, I have the following situation:

• Passing correct data works perfectly.
• Passing wrong values or wrong keys crashes Neovim

I can get around this by never returning an error, instead using something like err_writeln. With this, passing wrong values/keys will correctly report an error back (no crashing).

Since the Function::from expects something that can return an error, I'm assuming this is unwanted behavior. This can be seen from the "mechanic" example by passing {manufacturer = "Nikola", miles = 20}, which returns nothing, and then mistyping the key, as {manufacture = "Nikola", miles = 20}, which crashes Neovim.

[airblast-dev]

err_writeln is depcrecated but echo should be fine

[GordianDziwis]

Do I understand this correctly?

This is supposed to crash:

#[nvim_oxi::plugin]
fn symbiont() -> nvim_oxi::Result<()> {
  Err(nvim_oxi::Error::Lua(nvim_oxi::lua::Error::PopEmptyStack))
}

[strottos]

I'm finding the same behaviour and this seems odd. In fact if I return any kind of error from any function it causes Neovim to crash. Surely this is unexpected behaviour, otherwise I have to guarantee that not only do I never panic, I never error in any way.

@GordianDziwis yes that does cause a crash, I just tried it. I can't find any way to return a legitimate error, and I can't see how I can build any realistic plugin that cannot error (and I really don't want to have to go around catching every error possible).

[airblast-dev]

I think the problem is calling lua's lua_error function. In general it should be fine but performing jumps over Rust stacks is unsound so my guess is thats the problem here, as I cant find anything else obviously problematic.

Even ignoring that there's a memory leak caused by the jump as err.to_string() is called right before the jump.

While using lua to report errors makes things cleaner its also kind of problematic. Neovim provides other ways to report errors so maybe using those would make more sense.

[strottos]

Yeah I think you're right, I had a look and it throws to lua_error without a return. I think a workaround might be for me to create custom errors, catch them at the top level of my plugin and use some kind of error writing from there.

[strottos]

I even wondered if this was happening in my specific version of NeoVim (I tend to self build a recent version and update it once a month or so) where it works fine in NeoVim 0.10 say. Shame NeoVim isn't very memory safe.

[strottos]

Yeah the workaround works, I'll go with this for now, basically doing this kind of thing:

pub fn set_config(config: Dictionary) {
    if let Err(e) = set_config_inner(config) {
        err_writeln(&format!("Error setting config: {}", e));
    }
}

fn set_config_inner(config: Dictionary) -> Result<(), Error> {
    <do stuff that might return an error>
}

I still think being able to return an error and it bubbles up would be ideal, or maybe some documentation around this workaround would be good. It also means (as per original post) that you can't really use the struct deserialization unless you absolutely know the columns match up, in my case the user would be the guy settings opts in something like lazy and a panic is not great there.

Also why is err_writeln deprecated @airblast-dev , you mention above. What's the alternative? print doesn't actually error, I kind of do want to properly get NeoVim to log it as an error. Can we have an error! macro instead maybe that does this?

Thanks for looking.

[ricardokl]

I've been using notify to report the error. You can do this at the very end, right before exporting the function. Everywhere else you just propagate the error.

I've been experimenting with using mlua to export the module instead of nvim-oxi, and it seems to work, so maybe they have a solution that could be copied over. It's still somewhat annoying since the error won't convert seamlessly, but I use the same trick, where I do it at the very end.

[airblast-dev]

Also why is err_writeln deprecated?

Its actually deprecated in neovim, not something specific to this library. My guess is its due to the function being a colored print. nvim_echo does the same but allows customizing the style on a per char basis. It also supports an error flag to just color the whole thing to the error color of a theme which makes this a better alternative IMO.

[GordianDziwis]

I am doing this as a workaround, it is just a raw draft. The general idea is it to wrap all functions exported to nvim and let those echo an error message instead of throwing an error.

#[derive(Debug, Snafu)]
pub enum Error {
    #[snafu(transparent)]
    InvalidConfig { source: config::Error },
}

trait Echo {
    fn to_echo(&self);
}

impl<T: Debug> Echo for T {
    fn to_echo(&self) {
        let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S %Z").to_string();
        let component = "Symbiont";
        let error_text = format!("{:#?}", self);
        let echo_opts = EchoOptsBuilder::default().build();

        echo(
            [
                (format!("{} ", timestamp), None),
                ("[Error]".to_owned(), Some("Error")),
                (format!(" [{}] ", component), None),
                (error_text, None),
            ],
            true,
            &echo_opts,
        )
        .unwrap();
    }
}

pub type Result<T> = std::result::Result<T, Error>;

trait NvimSafe<T> {
    fn nvim_safe(self) -> nvim_oxi::Result<()>;
}

impl<T> NvimSafe<T> for Result<T> {
    fn nvim_safe(self) -> nvim_oxi::Result<()> {
        match self {
            Ok(_) => nvim_oxi::Result::Ok(()),
            Err(err) => {
                err.to_echo();
                nvim_oxi::Result::Ok(())
            }
        }
    }
}

#[nvim_oxi::plugin]
fn symbiont() -> Dictionary {
    let setup: Function<_, nvim_oxi::Result<()>> =
        Function::from_fn(|config| setup(config).nvim_safe());

    Dictionary::from_iter([("setup", Object::from(setup))])
}

[strottos]

This is great @GordianDziwis, thank you 👍

[patata3000]

I am doing this as a workaround, it is just a raw draft. The general idea is it to wrap all functions exported to nvim and let those echo an error message instead of throwing an error.

Hey Thank you ! How would you handle functions that return some specific types? I'm thinking of going for T: Default or smth similar but it feels clunky as the nvim could do something unwanted with it. It's a bit of a pain to handle this by hand.

[GordianDziwis]

Hey Thank you ! How would you handle functions that return some specific types? I'm thinking of going for T: Default or smth similar but it feels clunky as the nvim could do something unwanted with it. It's a bit of a pain to handle this by hand.

I did not find a way around needing T: Default if you want to return T.