TAIT: "unconstrained opaque type" error even if it's constrained

[Dirbaio]

This is allowed:

    type T = impl Copy;
    let foo: T = (1u32, 2u32);

But this isn't:

    type T = impl Copy;  // error: unconstrained opaque type
    let foo: T = (1u32, 2u32);
    let (a, b) = foo;

It seems strange to me that adding code causes a type that was previously properly constrained to not longer be so. I'm not sure if it's a diagnostics issue, or if it should indeed be allowed...

See playground

rustc 1.62.0-nightly (a707f40 2022-04-29)

@rustbot label A-impl-trait F-type_alias_impl_trait

[oli-obk]

UPDATE: the below ICE is fixed now!

I don't think we can really allow this. No pattern but a straight up binding is a valid pattern for an opaque type. If you actually give that pattern a type

#![feature(type_alias_impl_trait)]

fn main() {
    type T = impl Copy;
    let foo: T = (1u32, 2u32);
    let (a, b): (u32, u32) = foo;
}

then we get a lot of ICEs from borrowck. The interesting ones are

error: internal compiler error: broken MIR in DefId(0:3 ~ inference[4f8b]::main) ((_1.0: u32)): can't project out of PlaceTy { ty: main::T, variant_index: None }
  --> /home/ubuntu/rust5/src/test/ui/type-alias-impl-trait/inference.rs:6:10
   |
LL |     let (a, b): (u32, u32) = foo;
   |          ^
   |
   = note: delayed at compiler/rustc_borrowck/src/type_check/mod.rs:855:31

error: internal compiler error: broken MIR in DefId(0:3 ~ inference[4f8b]::main) ((_1.1: u32)): can't project out of PlaceTy { ty: main::T, variant_index: None }
  --> /home/ubuntu/rust5/src/test/ui/type-alias-impl-trait/inference.rs:6:13
   |
LL |     let (a, b): (u32, u32) = foo;
   |             ^
   |
   = note: delayed at compiler/rustc_borrowck/src/type_check/mod.rs:855:31

These happen because we assume that if a pattern type checks, that we can actually destructure the thing that was moved into the pattern. Unfortunately for opaque types that isn't true.

I guess the simple solution would be to just forbid it. We could try to allow it, but I'm not sure how to do that in general without just throwing more logic into match checking and mir building. Just patching the type of foo as seen in the pattern logic could work though... basically only touch mir typeck and verification/sanitation to teach them about the types inferred from patterns

[nikomatsakis]

UPDATE: the below ICE is fixed now!

Other examples:

#![feature(type_alias_impl_trait)]

fn main() {
    type T = impl Copy;
    let foo: T = (1u32, 2u32);
    match foo {
        (a, b) => (),
    }
}

also gives an error (playground)

[nikomatsakis]

Also ICEs (playground):

#![feature(type_alias_impl_trait)]

fn main() {
    type T = impl Copy;
    let foo: T = Some((1u32, 2u32));
    match foo {
        None => (),
        Some((a, b)) => (),
    }
}

[oli-obk]

triage:

Implement a "opaque type downcast projection" in mir and insert appropriately

[JohnTitor]

Triage: #96572 (comment) and #96572 (comment) are fixed by #96515. The last one (#96572 (comment)) is still ICE.

[oli-obk]

Fun: these can all be triggered on stable, too:

#[allow(unconditional_recursion)]
fn foo(b: bool) -> impl Copy {
    let (mut x, mut y) = foo(false);
    x = 42;
    y = "foo";
    if b {
        panic!()
    } else {
        foo(true)
    }
}

and

fn foo(b: bool) -> Option<impl Copy> {
    if b {
        return None;
    }
    match foo(!b) {
        Some((mut x, mut y)) => {
            x = 42;
            y = "foo";
        }
        None => {}
    }
    None
}

[JohnTitor]

Re-opening as #98582 has been reverted: #99495