Type inference issues with well specified trait function call

[weiznich]

While debugging a recent build failure in diesel I noticed that type inference fails in situation where the type is fully specified. I've build the following minimal example for this:

#[derive(Debug)]
struct Error;

trait FromSql<ST, DB>: Sized {
    fn from_sql(bytes: &[u8]) -> Result<Self, Error>;
}

struct UuidST;
struct Integer;
struct Pg;

#[derive(Debug, PartialEq)]
struct Uuid;

struct OtherType;

// remove this rather unrelated impl to fix the compilation
impl PartialEq<OtherType> for Uuid {
    fn eq(&self, other: &OtherType) -> bool {
        false
    }
}


impl FromSql<UuidST, Pg> for Uuid {
    fn from_sql(bytes: &[u8]) -> Result<Self, Error> {
        todo!()
    }
}

impl FromSql<Integer, Pg> for i32 {
    fn from_sql(bytes: &[u8]) -> Result<Self, Error> {
        todo!()
    }
}

fn main() {
    let input = &[];
    
    let out = FromSql::<UuidST, Pg>::from_sql(input).unwrap();

    assert_eq!(Uuid, out);
}

This fails to compile with the following error:

error[[E0790]](https://doc.rust-lang.org/nightly/error_codes/E0790.html): cannot call associated function on trait without specifying the corresponding `impl` type
  --> src/main.rs:43:15
   |
7  |     fn from_sql(bytes: &[u8]) -> Result<Self, Error>;
   |     ------------------------------------------------- `FromSql::from_sql` defined here
...
43 |     let out = FromSql::<UuidST, Pg>::from_sql(input).unwrap();
   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
   |
help: use a fully-qualified path to one of the available implementations
   |
43 -     let out = FromSql::<UuidST, Pg>::from_sql(input).unwrap();
43 +     let out = <Uuid as FromSql<UuidST, Pg>>::from_sql(input).unwrap();
   |
43 -     let out = FromSql::<UuidST, Pg>::from_sql(input).unwrap();
43 +     let out = <i32 as FromSql<UuidST, Pg>>::from_sql(input).unwrap();
   |

This seems to be caused by the additional PartialEq implementation that breaks inferring the type of the out variable. For me it looks strange that rustc cannot infer that there is only a single possible impl that fulfills the given constraints, so it should be possible to infer the correct type here.

(Also even if that's desired behavior the suggestion is definitively off, as the second variant (that with i32 as FromSql<UuidST, Pg> would result in a compilation error.

Playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=1a20f58b8678382f922f0006217bbf60

Related: uuid-rs/uuid#787

rustc --version --verbose:

Build using the Nightly version: 1.86.0-nightly

(2025-01-17 6067b36314ab5eb2eb47)

[compiler-errors]

I don't think the underlying issue is fixable; the issue is by the time we get to the assert_eq call, the compiler has no way of testing in parallel the two choices of inference for out from applying the PartialEq trait, namely OtherType and Uuid. If we tested both of those choices of types together with proving the existing FromSql bound that comes from making the method call then only Uuid would succeed, but rust's inference algorithm isn't set up to do something so complex unfortunately.

I think the suggestion could use some work, tho.

[weiznich]

I would argue that you don't even need the assert_eq! line to infer the correct type for out as it's already well specified before that line. The inference algorithm could check which impls of FromSql<UuidSt, Pg> exist and if there is only one unambiguous type there resolve to that type. There is no need to test whether OtherType or Uuid implement FromSql by using that approach.