Inferring type succeeds with too little information

[glandium]

The following code fails to compile:

pub trait Bar {
    fn new() -> Self;
}

pub struct Foo {}

impl Bar for Foo {
    fn new() -> Self {
        Foo {}
    }
}

pub struct Qux<B=Foo> where B: Bar {
    foo: B,
}

impl<B> Qux<B> where B: Bar {
    fn new() -> Self {
        Qux { foo: B::new() }
    }
}

fn main() {
    let q = Qux::new();
}

The error is:

rustc 1.14.0-nightly (6e8f92f11 2016-10-07)
error[E0282]: unable to infer enough type information about `_`
  --> <anon>:24:13
   |
24 |     let q = Qux::new();
   |             ^^^^^^^^ cannot infer type for `_`
   |
   = note: type annotations or generic parameter binding required

error: aborting due to previous error

(from playpen ; same with stable)

Strangely, replacing that failing line with:

    let q: Qux = Qux::new()

makes it compile.

[estebank]

Triage: current output:

error[E0282]: type annotations needed for `Qux<B>`
  --> src/main.rs:24:13
   |
24 |     let q = Qux::new();
   |         -   ^^^^^^^^ cannot infer type for `B`
   |         |
   |         consider giving `q` the explicit type `Qux<B>`, where the type parameter `B` is specified

Giving q the type Qux (without the assoc type set) still works.

[estebank]

Current output:

error[E0282]: type annotations needed for `Qux<B>`
  --> f71.rs:26:9
   |
26 |     let q = Qux::new();
   |         ^
   |
help: consider giving `q` an explicit type, where the type for type parameter `B` is specified
   |
26 |     let q: Qux<B> = Qux::new();
   |          ++++++++

After #114811:

error[E0283]: type annotations needed for `Qux<B>`
  --> f71.rs:26:9
   |
26 |     let q = Qux::new();
   |         ^   -------- type must be known at this point
   |
   = note: cannot satisfy `_: Bar`
   = help: the trait `Bar` is implemented for `Foo`
note: required by a bound in `Qux::<B>::new`
  --> f71.rs:19:25
   |
19 | impl<B> Qux<B> where B: Bar {
   |                         ^^^ required by this bound in `Qux::<B>::new`
20 |     fn new() -> Self {
   |        --- required by a bound in this associated function
help: consider giving `q` an explicit type, where the type for type parameter `B` is specified
   |
26 |     let q: Qux<B> = Qux::new();
   |          ++++++++