Clarify our story with `as` and type placeholders.

[Kimundi]

Right now the compiler accepts partial type hints for casts with as like this:

let x = &5 as *_;

However, it fails with a fully unrestricted type on the right hand side with a unhelpful error message:

.../type_hole_1.rs:35:18: 35:22 error: the type of this value must be known in this context
.../type_hole_1.rs:35     let a: int = 1u32 as _;
                                       ^~~~

To quote @nikomatsakis:
"The reason that the type check doesn't work is because we check immediately that the as conversion is legal. We could just say that the type of <expr> as T is T and then go back and check later that the type conversion is legal once types are known. I kind of like that."

There are three possible ways to resolve this:

• Explicitly allow type placeholders in as, which means fixing the as _ case.
• Explicitly forbid type placeholders in as, which means preventing partial type hints in as in general.
• Only forbid as _, while allowing partial type hints otherwise. This means catching the error case and emitting a useful error message.

[reem]

Triage: this is still a problem, and is now worse because let a: int = 5u as _; now ICEs rather than just erroring.

EDIT: I originally misread the issue

[steveklabnik]

 let x = &5 as *const _;

now works just fine.

[Kimundi]

as X<_> always worked just fine, its the as _ case that is the problem. :)

[steveklabnik]

Ugh, sorry :(

[nikomatsakis]

Interestingly, the fact that x as *const _ works is kind of an accident. That is, the code is not "intending" for it to work -- it is setup to have as not influence type inference at all -- but due to a bug it does, and I figure it's too entrenched to break. (It's dang convenient, that's for sure!)

[arielb1]

@nikomatsakis

Not really. The casted-to type (*const _) is the cast expression's return type, which is later unified with the expression's expected type. Actual cast checking, which takes place fairly late, sees the cast as x as *const u8. The reason this doesn't work with as *const _ is because of a dubious type_is_known_to_be_sized check at https://github.com/rust-lang/rust/blob/master/src/librustc_typeck/check/mod.rs#L3495.

I feel like we should move it to cast checking. Should I write a PR?

[nikomatsakis]

@arielb1

Not really. The casted-to type (*const _) is the cast expression's return type, which is later unified with the expression's expected type.

This is how it is supposed to work, yes, but I think there are cases where the value is not fully inferred before casts are processed. At some point I was introducing more hard errors before cast checking for unresolved variables, and I got errors for this reason, and had to modify the code some. I'd have to go back digging to be more precise though.

[Mark-Simulacrum]

The following now successfully compiles, so we've effectively clarified the story, since as far as I know we cannot change this in a backwards compatible way. Closing since there appears to be nothing left to do in this issue.

fn main() {
    let a: i32 = 1u32 as _;
}