Closure inference is destroyed by wrappers

[ebfull]

This doesn't work:

struct Wrapper<F>(F);
struct Foo;

impl Foo {
    fn stuff(self) { }
}

fn api<F: Fn(Foo)>(f: Wrapper<F>) { }

fn main() {
    api(Wrapper(|b| {
        b.stuff();
    }))
}

yet without the wrapper it works just fine:

struct Foo;

impl Foo {
    fn stuff(self) { }
}

fn api<F: Fn(Foo)>(f: F) { }

fn main() {
    api(|b| {
        b.stuff();
    })
}

[arielb1]

Overloading inference evaluates a function in visitor order, so this is expected.

[arielb1]

I mean, even without closures:

struct Foo;

impl Foo {
    fn stuff(self) {}
}

fn compiles() {
    let mut x = None;
    loop {
        x = Some(Foo);
        if let Some(s) = x { s.stuff(); }
    }
}


fn does_not_compile() {
    let mut x = None;
    loop {
        if let Some(s) = x { s.stuff(); } //~ ERROR the type of this value must be known
        x = Some(Foo);
    }
}

fn main() {}

[ebfull]

Can you reopen this? It merits more discussion I think.

edit: edited OP

[ebfull]

cc @nikomatsakis

[ebfull]

You can keep this issue closed as a duplicate of #25165.

[arielb1]

@ebfull

Your second issue is different enough. Could you edit your OP to represent that?

From my investigation, the problem is that we don't relate the return type of Wrapper to the argument type of api, because we are afraid there might be a coercion involved. This means the bound information is not passed to the closure. We could try to be better here - cc @nikomatsakis @eddyb.

[eddyb]

@arielb1 I think that downward propagation is always supposed to happen, this looks like a missing case.

[arielb1]

Duplicate of #20841. Closing and nominating that one.