Add trait bound to generic on derive

[Sytten]

Context

I would like to be able to write:

pub type UpstreamProxyInsertSetPlain = UpstreamProxyInsertSet<UpstreamProxyAuth>;
pub type UpstreamProxyInsertSetEnc = UpstreamProxyInsertSet<UpstreamProxyAuthEnc>;

#[derive(Insertable, Clone)]
#[diesel(table_name = upstream_proxies_app)]
pub struct UpstreamProxyAppInsertSet<T> {
    pub kind: UpstreamProxyAppKind,
    pub enabled: bool,
    pub host: String,
    pub port: Port,
    pub auth: Option<T>,
    pub allowlist: DomainSet,
    pub denylist: DomainSet,
}

impl UpstreamProxyInsertSet<UpstreamProxyAuth> {
    pub fn encrypt(self, key: &Secret) -> anyhow::Result<UpstreamProxyInsertSetEnc> {
        let auth = match self.auth {
            Some(a) => Some(a.encrypt(key)?),
            None => None,
        };
        Ok(UpstreamProxyAppInsertSet {
            kind: self.kind,
            enabled: self.enabled,
            host: self.host,
            port: self.port,
            auth,
            allowlist: self.allowlist,
            denylist: self.denylist,
        })
    }
}

• UpstreamProxyAuth doesn't implement ToSql/FromSql
• UpstreamProxyAuthEnc does

Problem

I am unsure why AsChangeset doesn't complain, but Insertable requires to bound the trait as:

#[derive(Insertable, Clone)]
#[diesel(table_name = upstream_proxies_app)]
pub struct UpstreamProxyAppInsertSet<T>
where
    T: Expression<SqlType = Nullable<Text>>,
{
    pub kind: UpstreamProxyAppKind,
    pub enabled: bool,
    pub host: String,
    pub port: Port,
    pub auth: Option<T>,
    pub allowlist: DomainSet,
    pub denylist: DomainSet,
}

But this doesn't allow me to implement the plain text version since I don't want it to insertable.

Possible Solution

What I have seen other derive macros do is to add the trait bound on the generated implementation.
For example Clone:

impl<T: $crate::clone::Clone> $crate::clone::Clone for UpstreamProxyInsertSet<T>
where
    T: Expression<SqlType = Nullable<Text>>,
{
    fn clone(&self) -> Self {
        match self {
            UpstreamProxyInsertSet {
                kind: kind,
                enabled: enabled,
                host: host,
                port: port,
                auth: auth,
                allowlist: allowlist,
                denylist: denylist,
            } => UpstreamProxyInsertSet {
                kind: kind.clone(),
                enabled: enabled.clone(),
                host: host.clone(),
                port: port.clone(),
                auth: auth.clone(),
                allowlist: allowlist.clone(),
                denylist: denylist.clone(),
            },
        }
    }
}

Now that might be hard for the macro to build, but maybe simple cases could be supported?

[weiznich]

I think that might be reasonable to do, although it's not clear where the bound should exactly come from. Especially the information about the SQL type is missing. We cannot just hardcode type mappings there as users can define their own types on both sides.

What might work is to construct this type out of the target column, so something like dsl::SqlTypeOf<#target_column> as we know the target column and can instruct rustc to use the type from there. I'm happy to accept a PR for that as long as it comes with a test.

(Beside that T: Expression is the wrong bound, that needs to be T: AsExpression<Text>, that's again rustc trying to be too helpful.)