Inferring type succeeds with too little information

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.

1. 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.

   Esteban Kuber at 2019-08-12 20:53:02

2. 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();
      |          ++++++++
   

   Esteban Kuber at 2023-08-14 13:45:36