impl traits in consts through const fns are allowed but shouldn't

[spastorino]

The following code compiles after #87141 but shouldn't

#![feature(const_impl_trait)]
#![feature(min_type_alias_impl_trait)]

type Foo = impl Send;

struct A;

const VALUE: Foo = value();

 const fn value() -> Foo {
     A
 }

fn main() {
}

[tyranron]

@spastorino could you please clarify why this should be forbidden? Seems like a nice feature to have, keeping in mind that there is a lot of anonymous types usages in Rust code.

[spastorino]

Ohh sorry for the lack of explanation, to be clear, this should be supported at some point. We were in the middle of removing impl traits in bindings for min_taits and the example in this issue is part of that combo that we were removing. In that sense is that it shouldn't work, because we were removing it's support. At some point when let bindings are reintroduced this example should work :). Sorry for the lack of context provided.

@oli-obk maybe you want to add a bit more info here.

[oli-obk]

We are trying to avoid any and all mentions of traits other than Sized from const fn until we have a proper story here. you can't use the result of an impl trait returning const fn within another const fn anyway, so the usefulness is limited.

[clarfonthey]

Are there any particularly challenging caveats here or does this just need const expressions to have a "type filter" that forbids TAIT types?

[oli-obk]

well.. I have recently come around to "just allowing trait bounds" in const stuff and requiring explicit const bounds (placeholder syntax ~const right now on nightly). So if we can RFC that, we can get function pointers, impl trait and dyn trait all in const fn, and they'll just not be callable from within the const fn.

[clarfonthey]

I guess that my main reason for asking is that this seems like the biggest blocker for getting TAIT stabilised in at least a minimal form, and I'm mostly looking for what needs to be done before I can have nameable, zero-sized function types, which requires TAIT for the moment.

Am currently trying to figure out whether it would be easier to get TAIT stabilised, or figure out some feature to add named function types that doesn't require TAIT and implementing that. Definitely leaning toward the former, but mostly just wanna figure out the details.

[oli-obk]

I would presume that TAIT in const (without the ability to call methods on it) would be faster to stabilize, since it's already fully implemented and "just" needs stabilization.

[oli-obk]

We have stabilized -> impl Trait on const fn, so there is no reason to forbid TAITs.

Closing as there is no further action required here