Pass opaque types for the type_alias_bounds lint

[mu001999]

Fixes #108617

[rustbot]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @lcnr (or someone else) soon.

Please see the contribution instructions for more information. Namely, in order to ensure the minimum review times lag, PR authors and assigned reviewers should ensure that the review label (S-waiting-on-review and S-waiting-on-author) stays updated, invoking these commands when appropriate:

• @rustbot author: the review is finished, PR author should check the comments and take action accordingly
• @rustbot review: the author is ready for a review, this PR will be queued again in the reviewer's queue

[mu001999]

r? @lcnr

[rustbot]

Could not assign reviewer from: lcnr.
User(s) lcnr are either the PR author or are already assigned, and there are no other candidates.
Use r? to specify someone else to assign.

[lcnr]

r? @oli-obk

do we convert the whole type alias to an opaque for type Foo<T: Debug> = (impl Debug, usize); 🤔

[mu001999]

For this lint, there is not enough information at check time to determine if bounds are needed when opaque types appear on the right side. So I think in this case, the warning should not be emitted for now.

[oli-obk]

I think we should still lint if the non-opaque types contain generic params of the type alias. So for example:

type Foo<T: Debug> = (impl Foo<T>, T);

Also: please add a bunch of tests for various cases (other types using generic params, other types not using them, ...)

[mu001999]

@oli-obk Thanks! I pushed some new commits, only bounds whose ty-params or lifetimes-params are used in non-opaque types would be linted now. And I added some tests. :)

[mu001999]

Sorry, some tests failed, I will check the code.

[mu001999]

@oli-obk I have tried to only lint bounds whose ty is a generic parameter used in the non-opaque types if there is an opaque type. You can see the new commits. But it still lead to some false positives. For the following code, the bound T: 'a cannot be removed and will trigger the warning:

#![feature(type_alias_impl_trait)]
#![allow(dead_code)]

use std::fmt::Debug;

type Foo<'a, T: 'a> where &'a T: Debug = (impl Debug + 'a, T);
fn foo<'a, U: Debug + 'a>(v: U) -> Foo<'a, U> where &'a U: Debug {
    (Vec::<&'a U>::new(), v)
}

So, I think the best way is to not lint the type when meeting opaque types. What do you think?

[lcnr]

just want to throw this out there, but could we change only type aliases with opaque types to actually get treated as alias types and completely disable the lint for those?

I think our longterm goal is to check wf for trait aliases anyways, so this feels like a step in the right direction 🤔

[oli-obk]

could we change only type aliases with opaque types to actually get treated as alias types

you mean, adding TyKind::Alias but only using it for type aliases that have an opaque type in them?

longterm goal is to check wf for trait aliases anyways

I think you mean type aliases, but yes 😆

[mu001999]

Sounds good, maybe this PR should be closed :)

[oli-obk]

Thanks for opening the PR! We found a good design due to it, I'll assign the issue to myself