RPIT allows defining use with invalid args

[aliemjay]

Note: All examples in this post was fixed in #112842. However the issue persists for lifetime arguments. See this comment for more.

---

The following compiles since v1.62:

fn foo<T>() -> impl Sized {
    let _: () = foo::<u8>();
}

While the equivalent TAIT version doesn't compile because Opaque<u8> == u8 is not a valid defining use for Opaque (because it is ambiguous whether Opaque<T> = T or Opaque<T> = u8):

#![feature(type_alias_impl_trait)]

type Opaque<T> = impl Sized;
fn foo<T>() -> Opaque<T> {
    let _: () = foo::<u8>();
    //~^ ERROR expected generic type parameter, found `u8`
}

I believe that TAIT behavior is the correct one because it's maximally compatible with future changes. Keeping this behavior for RPIT can also result in some surprising errors:

fn foo<T>(val: T) -> impl Sized {
    let _: u8 = foo(0u8);
    val
    //~^ ERROR concrete type differs from previous defining opaque type use
}

This was stabilized (most likely unintentionally) in #94081. Cc @oli-obk.

See related code:

rust/compiler/rustc_borrowck/src/region_infer/opaque_types.rs

Line 335 in 776f222

fn check_opaque_type_parameter_valid(

[apiraino]

WG-prioritization assigning priority (Zulip discussion).

@rustbot label -I-prioritize +P-high

[aliemjay]

The PR #112842 fixed this issue for type arguments. The same issue persists for lifetime arguments.

The following snippets are examples of invalid defining uses that should not compile:

// Lt indirection is necessary to make the lifetime of the function late-bound,
// in order to bypass some other bugs.
type Lt<'lt> = Option<*mut &'lt ()>;

// PASS!
#[cfg(case1)]
fn foo<'a>(_: Lt<'a>) -> impl Sized + 'a {
    let _: () = foo(Lt::<'static>::None);
    // invalid defining use: Opaque<'static> := ()
}

// ICE!
#[cfg(case2)]
fn foo<'a>(_: Lt<'a>) -> impl Sized + 'a {
    let _: () = foo(Lt::<'_>::None);
    // invalid defining use: Opaque<'_> := ()
}

// PASS!
#[cfg(case3)]
fn foo<'a, 'b>(_: Lt<'a>, _: Lt<'b>) -> impl Sized + 'a + 'b {
    let _: () = foo(Lt::<'a>::None, Lt::<'a>::None);
    // invalid defining use: Opaque<'a, 'a> := ()
    // because of the use of equal lifetimes in args
}

[lcnr]

cc #113916