Allow trait bounds to be overridden in macro

[lexnv]

This PR adds the server_bounds and client_bounds attributes of the rpc macro.

The attributes allow users to specify custom bounds for their traits, as a way to opt-out
of the default Send + Sync + 'static where appropriate.

Example

Without the custom provided bounds, the RPC macro would add by default
Conf : Send + Sync + 'static + jsonrpsee::core::DeserializeOwned for client implementation and
Conf : Send + Sync + 'static + jsonrpsee::core::Serialize for server implementation.
This rule is quite restrictive, as we need just Conf::Hash to comply to those rules.

pub trait Config {
	type Hash: Send + Sync + 'static;
}

impl Config for ExampleHash {
	type Hash = Self;
}

#[rpc(server, client, namespace = "foo", client_bounds(Conf::Hash: jsonrpsee::core::DeserializeOwned), server_bounds(Conf::Hash: jsonrpsee::core::Serialize))]
pub trait Rpc<Conf: Config> {
	#[method(name = "bar")]
	fn method(&self) -> Result<Conf::Hash, Error>;
}

While at it, add a new example illustrating the custom bounds and a few UI tests to capture
proper error messages.

Closes #696.

[niklasad1]

IIRC: before/"currently" we add the trait bound the entire trait right?

Can you just verify that we don't add trait bounds on associated types that are not used in the RPC trait?

such as:

pub trait Config {
   type Hash: Send + Sync + 'static;
   type NotUsed;
}

[lexnv]

Debugging the proc-macro, it seems that "currently" (without custom bounds attribute):

pub trait Config {
	type Hash: Send + Sync + 'static;
	type NotUsed;
}

#[rpc(server, namespace = "foo")]
pub trait Rpc<Conf: Config> {
	#[method(name = "bar")]
	fn method(&self) -> Result<Conf::Hash, Error>;
}

The rpc macro implies just: Conf : Send + Sync + 'static + jsonrpsee :: core :: Serialize.

Although, this fails to compile due to:

55  | #[rpc(server, client, namespace = "foo", client_bounds(Conf::Hash: jsonrpsee::core::DeserializeOwned))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Serialize` is not implemented for `<Conf as Config>::Hash`

[niklasad1]

Yeah, that's fine I meant with the overrides for the Hash

pub trait Config {
	type Hash: Send + Sync + 'static;
	type NotUsed;
}

#[rpc(server, client, client_bounds(Conf::Hash: jsonrpsee::core::Serialize))]
pub trait Rpc<Conf: Config> {
	#[method(name = "bar")]
	fn method(&self) -> Result<Conf::Hash, Error>;
}

Such that it doesn't expand to something like:

pub trait Rpc<T: Client, C: Config> 
where 
        C::Hash: Serialize,
        // NotUsed is not used so the trait bounds are needless
        // and should not be added.
        C::NotUsed: Send + Sync + Serialize + DeserializeOwned
{
	#[method(name = "bar")]
	fn method(&self) -> Result<Conf::Hash, Error>;
}

But as it works in subxt all fine, IIRC we only inspect the parameters and return types anyway and add bounds on them so all good.

[niklasad1]

great.

some UI tests that it actually work as well then this should be ready to go :)

[niklasad1]

I just tested in on my hacky subxt RPC macro PR and it works 🎉

paritytech/subxt#431

[niklasad1]

👍

[niklasad1]

excellent, nice work

some minor suggestions on testing but really good to have this finally

[jsdw]

Just wondering; is it possible to define something like:

#[rpc(server, client, client_bounds(Conf::Hash: jsonrpsee::core::Serialize))]
pub trait Rpc<Conf: Config> {
	fn generic_input<T>(&self, input: T) -> Result<Conf::Hash, Error>;
        fn generic_output<O>(&self, input: T) -> Result<O, Error>;
}

And if so, can we control the bounds of T and O? This may be a dumb question :)

[jsdw]

Not sure whether the question above makes sense or not (I can't recall whether it's possible to add generic bounds in that way), but regardless, this looks great; nice job!

[lexnv]

Managed to define something similar:

#[rpc(client, client_bounds(
	Conf::Hash: jsonrpsee::core::DeserializeOwned,
	T: jsonrpsee::core::Serialize + Send + Sync + 'static,
	O: jsonrpsee::core::DeserializeOwned)
)]
pub trait Rpc2<Conf: Config, T, O> {
	#[method(name = "bar")]
	fn generic_input<T>(&self, input: T) -> Result<Conf::Hash, Error>;
	#[method(name = "foo")]
	fn generic_output<T, O>(&self, input: T) -> Result<O, Error>;
}

with T: jsonrpsee::core::Serialize + Send + Sync + 'static (as it is input for client) and O: jsonrpsee::core::DeserializeOwned (output)

[niklasad1]

Just wondering; is it possible to define something like:

#[rpc(server, client, client_bounds(Conf::Hash: jsonrpsee::core::Serialize))]
pub trait Rpc<Conf: Config> {
	fn generic_input<T>(&self, input: T) -> Result<Conf::Hash, Error>;
        fn generic_output<O>(&self, input: T) -> Result<O, Error>;
}

And if so, can we control the bounds of T and O? This may be a dumb question :)

Bounds on individual methods doesn't work because the server generates fn into_rpc(self) -> jsonrpsee::RpcModule<Self> and then these "type params" are not bound to anything so it won't compile.

We would need to find all individual type params and generate fn into_rpc<T1, ... Tn>(self) -> jsonrpsee::RpcModule<Self>
then it would work I guess.

I think the same applies to client trait too i.e, that we don't really parse type params on individual methods.

I guess we should throw a compile error for bounds on individual methods until that's allowed, you must really have a bound on the entire trait for now.