Introduce Spanned toml deserialization, add some validation/tests

[Gankra]

Spanning is done with the Spanned hack from toml-rs. A bunch of serialization code had to be rejigged
to play nice with that hack. In particular things like flatten and untagged_enum make it freak out, so
now we deserialize all the fields and then pick which variant it is.

Store now records the source files it imported, and we now check that criteria names are valid everywhere.
New tests allow us to quickly check different inputs parse/fail-parse/fail-validate.

[Gankra]

I have been struggling in a mental labyrinth trying to get the Spanned stuff to work with all the weird parsing hacks we already had for like the last week, and ended up obsessively working on it this sunday just to get it out of my head, so I'll take off some other day this week to make up.

[Gankra]

beautiful ;-;

[mystor]

I wonder if we could use better values to indicate that the span isn't specified, so we can handle that case better? We could e.g. use usize::MAX?

[Gankra]

I've found miette can be a bit brittle in degenerate source/span situations (panics on the empty string being a NamedSource), so (0,0) is safer. In practice we only really set spans when we're about to writeback, in which case their values don't matter (but this may change in the future).

[mystor]

IIRC generally column isn't 1-indexed, unlike line. Is this correct?

[Gankra]

These offsets were determined by empirical checking, everyone's got weird opinions it seems.

[mystor]

Hmm, I don't love that we're cloning the string here, when we really only need one copy, as deserialization doesn't require us to actually own the payload.

Unfortunately it looks like miette throws out the type information as soon as you call NamedSource::new so it would be quite the hassle to get back out a &str for the full source file. Could we perhaps rework this like this:

let mut string = String::new();
reader.read_to_string(&mut string)?;
let result = toml::de::from_str(&string);
let source_code = Arc::new(NamedSource::new(file_name, string.clone()));
match result {
    Ok(toml) => Ok((source_code, toml)),
    Err(error) => {
        let (line, col) = error.line_col().unwrap_or((0, 0));
        Err(TomlParseError {
            source_code,
            span: SourceOffset::from_location(&string, line + 1, col),
            error,
        })
    }
}

[Gankra]

I'm not sure I follow, you seem to still be cloning the string?

[mystor]

Oops, well I meant to remove the .clone(), but forgot to. I also totally missed that you need the string to do SourceOffset::from_location. Something like this should work IIRC (though it has some duplication)

let mut string = String::new();
reader.read_to_string(&mut string)?;
let result = toml::de::from_str(&string);
match result {
    Ok(toml) => Ok((Arc::new(NamedSource::new(file_name, string)), toml)),
    Err(error) => {
        let (line, col) = error.line_col().unwrap_or((0, 0));
        Err(TomlParseError {
            span: SourceOffset::from_location(&string, line + 1, col + 1),
            source_code: Arc::new(NamedSource::new(file_name, string)),
            error,
        })
    }
}

[Gankra]

I iterated on this and now we don't clone the string

[Gankra]

ah nice, same impl :)