Inconsistent type inferring

[therustmonk]

I've found the case where type inferring is inconsistent (I think so):

use std::any::Any;
use std::sync::{Arc, Mutex};

pub type Wild = Box<Any + 'static + Send>;

pub fn with_wild(_: Option<Arc<Wild>>) { }

struct Modest;

fn main() {

    // Works
    with_wild(Some(Arc::new(Box::new(Mutex::new(Modest)))));

    // Doesn't work
    let fluffy = Some(Arc::new(Box::new(Mutex::new(Modest))));
    with_wild(fluffy); 

}

at playground

It fails with:

error[E0308]: mismatched types
  --> <anon>:17:15
   |
17 |     with_wild(fluffy);
   |               ^^^^^^ expected trait std::any::Any, found struct `std::sync::Mutex`
   |
   = note: expected type `std::option::Option<std::sync::Arc<Box<std::any::Any + Send + 'static>>>`
   = note:    found type `std::option::Option<std::sync::Arc<Box<std::sync::Mutex<Modest>>>>`

error: aborting due to previous error

[Aatch]

This isn't really inconsistent. The reason the first one works and the other doesn't is because there's no inference happening in the first case. with_wild takes an Option<Arc<Box<Any + 'static + Send>>>, so when we check the type of Some(Arc::new(Box::new(Mutex::new(Modest)))) we can use the argument type. The type mismatch between Box<Mutex<Modest>> and Box<Any> is handled with a coercion from one to the other. In the second case, we don't have an pre-existing type information to go by, so we just infer the type of fluffy to be Option<Arc<Box<Mutex<Modest>>>.

Coercions aren't part of type inference, they're applied when we encounter a type mismatch, there's not really any inconsistency here. I don't think this behaviour will change, so this should probably be closed. @rust-lang/lang sound good?

[eddyb]

@Aatch Indeed, in the first case the type information propagates down through Some and the Arc so the coercion is applied on the Box<_> whereas in the second case, fluffy is already an Option<Arc<Box<Mutex<_>>>> which doesn't coerce to anything.
You could argue that Option<T> should get T's coercions (see also rust-lang/rfcs#1403), but that won't help Arc<Box<_>>, as the Arc's allocation can't be changed after creation.

If you remove the double boxing (which AFAICT is completely redundant), you can work around it:

use std::any::Any;
use std::sync::{Arc, Mutex};

pub type Wild = Any + 'static + Send;

pub fn with_wild(_: Option<Arc<Wild>>) { }

struct Modest;

fn main() {

    // Works
    with_wild(Some(Arc::new(Mutex::new(Modest))));

    let fluffy = Some(Arc::new(Mutex::new(Modest)));
    with_wild(fluffy.map(|x| x as Arc<Wild>));

}

You can also do the manual case on the original fluffy line. I was hoping .map would coerce with just |x| x, but that doesn't work with methods, only free functions.