the type of the expression with an operator doesn't inferred correctly

[mandel59]

use std::ops::Add;

#[cfg(error)]
fn foo<T>(x: T) -> <i32 as Add<T>>::Output where i32: Add<T> {
    42i32 + x
}

#[cfg(not(error))]
fn foo<T>(x: T) -> <i32 as Add<T>>::Output where i32: Add<T> {
    Add::add(42i32, x)
}

fn main() {
    println!("{}", foo(0i32));
}

This fails to compile:

% rustc assoc.rs --cfg error
assoc.rs:5:13: 5:14 error: mismatched types: expected `i32`, found `T` (expected i32, found type parameter)
assoc.rs:5     42i32 + x
                       ^
assoc.rs:5:5: 5:14 error: mismatched types: expected `<i32 as core::ops::Add<T>>::Output`, found `i32` (expected associated type, found i32)
assoc.rs:5     42i32 + x
               ^~~~~~~~~
error: aborting due to 2 previous errors

[arturoc]

probably related, this:

pub fn lerp<T: Add + Mul<f32>>(p0: T, p1: T, pct: f32) -> T{
    p0 * (1.0 - pct) + p1 * pct
}

fails to compile with:
error: binary operation + cannot be applied to type <T as core::ops::Mul<f32>>::Output

this used to compile but not sure if it's a bug or the syntax has changed

[mandel59]

@arturoc This works:

pub fn lerp<T: Add<Output = T> + Mul<f32, Output = T>>(p0: T, p1: T, pct: f32) -> T {
    p0 * (1.0 - pct) + p1 * pct
}

It should be the intended behavior.

[arturoc]

thanks!

[huonw]

This now works after Niko's refactoring work. (Adding needstest, since I can't find a test that tests this exactly, although I wasn't looking very hard.)