feat: implement full features as a derivative work of serde_json_path

[tisonkun]

Modifications:

• Drop serde related impls.
• impl Ord for PathElement
• Drop Integer wrapper (although it's a MUST in RFC 9535, I don't find the reason and highly suspect it's because JSON has only numbers (IEEE 754 float))
• The function registry has been totally re-designed to generic over any VariantValue type.

[tisonkun]

Hi @epage!

Here when I use winnow, I need to parse a state FunctionRegistry top to down.

I wonder if we have better way to convey the state instead of impl Parser<TokenSlice<'a>, Query, Error> and move |input: &mut TokenSlice<'a>| every where.

[epage]

Can you instead pass state through Stateful?

btw you can usually annotate your closures with just &mut _

[tisonkun]

btw you can usually annotate your closures with just &mut _

Sounds good.

Can you instead pass state through Stateful?

I try this in the latest commit but it fails to compile:

error[E0599]: the method `map` exists for tuple `(fn(&mut Stateful<..., ...>) -> ... {parse_root_query::<...>}, ...)`, but its trait bounds were not satisfied
  --> spath/src/parser/parse.rs:43:10
   |
42 | /     (parse_root_query, EOI)
43 | |         .map(|(query, _)| query)
   | |         -^^^ method cannot be called due to unsatisfied trait bounds
   | |_________|
   |
   |

error[E0596]: cannot borrow data in dereference of `Stateful<winnow::stream::TokenSlice<'_, Token<'_>>, ParseContext<R>>` as mutable
  --> spath/src/parser/parse.rs:48:52
   |
48 |     text("$").map(|_| Query::default()).parse_next(input)
   |                                                    ^^^^^ cannot borrow as mutable
   |
   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Stateful<winnow::stream::TokenSlice<'_, Token<'_>>, ParseContext<R>>`

Not quite sure how to properly type it.

[epage]

The second error is a type mismatch between text (TokenStream) and parse_root_query (Stateful<_, _>)

For the first, did you implement Parser for `TokenKind? Not too easy to search for that in the browser. If so, you likely also need to make the Input type generic.

[tisonkun]

@epage Thanks for your information! All works well now.

I'd finish the filter expr parsing part and then dig into how to properly report the parse error.

I've made a span-based error reporting strategy elsewhere with nom, and would like to see how to reimplement it with winnow.

[tisonkun]

@epage I notice a wart of Stateful that I cannot get a ref in mapper because parse_next needs a mutable ref.

I must wrap the registry in Arc as:

pub type TokenSlice<'a> = winnow::stream::TokenSlice<'a, Token<'a>>;

pub type Input<'a, Registry> = Stateful<TokenSlice<'a>, InputState<Registry>>;

pub struct InputState<Registry> {
    registry: Arc<Registry>,
}

impl<Registry> InputState<Registry> {
    pub fn new(registry: Registry) -> Self {
        let registry = Arc::new(registry);
        Self { registry }
    }

    pub fn registry(&self) -> Arc<Registry> {
        self.registry.clone()
    }

    pub fn into_registry(self) -> Registry {
        // SAFETY: The registry is only owned by this instance.
        Arc::into_inner(self.registry).unwrap()
    }
}

If I use barely Registry and return &self.registry in input.state.registry(), a compile error would occur:

error[E0502]: cannot borrow `*input` as mutable because it is also borrowed as immutable
   --> spath/src/parser/parse.rs:491:5
    |
489 |       let registry = input.state.registry();
    |                      ----------- immutable borrow occurs here
490 |
491 | /     (
492 | |         Identifier,
493 | |         delimited(
494 | |             text("("),
...   |
512 | |         })
513 | |         .parse_next(input)
    | |__________----------______^ mutable borrow occurs here
    |            |
    |            immutable borrow later used by call

[epage]

Sounds like the core of the issue is with accessing InputState inside of try_map. Our issue for this is winnow-rs/winnow#231.

A workaround is to not use try_map

    let (name, args) = (
        Identifier,
        delimited(
            text("("),
            separated(0.., parse_function_argument, text(",")),
            text(")"),
        ),
    ).parse_next(input)?;

            let name = name.text().to_string();
            let args: Vec<FunctionExprArg> = args;
            let function = match registry.get(name.as_str()) {
                Some(function) => function,
                None => return Err(FunctionValidationError::Undefined { name }),
            };
            function.validate(args.as_slice(), registry.as_ref())?;
            Ok(FunctionExpr {
                name,
                args,
                return_type: function.result_type(),
            })

The only limitation being that you will need to manually convert the error type

[tisonkun]

Thanks a lot for your help @epage!

I use the workaround and all the happy path looks good now.

I'd merge this one and work on error reporting part. Basically, I'd track all the span and report error with context error, like:

error: failed to execute statement
  --> ScopeQL:1:8
  |
1 | $0[42::]
  | -  --  ^ unexpected `]`, expecting `INT`, `UINT`, `FLOAT`, `STRING`, `BOOLEAN`, `TIMESTAMP`, `INTERVAL`, or `VARIANT`
  | |  |    
  | |  while parsing expression
  | while parsing expression

But perhaps a more simple version.