rustc 可以给我更多关于类型歧义错误的细节吗？

Question

There is this familiar compilation error:

error[E0283]: type annotations required: cannot resolve `T: Constraint`

...

And then rustc --explain E0283 says: This error occurs when the compiler doesn't have enough information to unambiguously choose an implementation , and gives a helpful example .

I know exactly how to fix the error - see eg this answer .

I'm wondering, though, if rustc can be encouraged to tell me more. Specifically, some representation of the space of possible concrete types that the type checker ended up with before bailing.

Answer 1

I cannot find any rustc options to provide more information on E0283; however the code for this error includes a comment that might give you a little more insight. Otherwise it seems that the answer to your question is no. Sorry I am not able to get more help.

Answer 2

When the type checker can't deduce an unambiguous type, it doesn't necessarily mean that it can't choose from some finite set of known contenders. Here is the example you are referring to from the documentation:

trait Generator {
    fn create() -> u32;
}

struct Impl;

impl Generator for Impl {
    fn create() -> u32 { 1 }
}

struct AnotherImpl;

impl Generator for AnotherImpl {
    fn create() -> u32 { 2 }
}

fn main() {
    let cont: u32 = Generator::create();
    // error, impossible to choose one of Generator trait implementation
    // Should it be Impl or AnotherImpl, maybe something else?
}

If AnotherImpl wasn't there, and Impl was the only implementation of Generator , this still wouldn't work. If it did, you could later add AnotherImpl — even in another module or crate — and break this code. In general, adding a new definition should be non-breaking, and certainly shouldn't be able to break code in another module. If the compiler automatically chose the "only" implementation of Generator here, it would violate that.

Coming back to your original question, the only information that the error message could give you is pretty much what it's already giving you. The type checker hasn't looked around for possible implementations, rather it has simply refused to even try to choose a type from the information given.