Handle `impl Trait` where `Trait` has an assoc type with missing bounds #69707

estebank · 2020-03-04T19:04:03Z

When encountering a type parameter that needs more bounds the trivial case is T where T: Bound, but it can also be an impl Trait param that needs to be decomposed to a type param for cleaner code. For example, given

fn foo(constraints: impl Iterator) {
    for constraint in constraints {
        println!("{:?}", constraint);
    }
}

the previous output was

error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug`
 --> src/main.rs:3:26
  |
1 | fn foo(constraints: impl Iterator) {
  |                                    - help: consider further restricting the associated type: `where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug`
2 |     for constraint in constraints {
3 |         println!("{:?}", constraint);
  |                          ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
  |
  = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item`
  = note: required by `std::fmt::Debug::fmt`

which is incorrect as where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug is not valid syntax nor would it restrict the positional impl Iterator parameter if it were.

The output being introduced is

error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug`
 --> src/main.rs:3:26
  |
3 |         println!("{:?}", constraint);
  |                          ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
  |
  = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item`
  = note: required by `std::fmt::Debug::fmt`
help: introduce a type parameter with a trait bound instead of using `impl Trait`
   |
LL | fn foo<T: Iterator>(constraints: T) where <T as std::iter::Iterator>::Item: std::fmt::Debug  {
   |       ^^^^^^^^^^^^^              ^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

This suggestion is correct and lead the user in the right direction: because you have an associated type restriction you can no longer use impl Trait, the only reasonable alternative is to introduce a named type parameter, bound by Trait and with a where binding on the associated type for the new type parameter as Trait for the missing bound.

Ideally, we would want to suggest something like the following, but that is not valid syntax today

error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug`
 --> src/main.rs:3:26
  |
3 |         println!("{:?}", constraint);
  |                          ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
  |
  = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item`
  = note: required by `std::fmt::Debug::fmt`
help: introduce a type parameter with a trait bound instead of using `impl Trait`
   |
LL | fn foo(constraints: impl Iterator<Item: std::fmt::Debug>) {
   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Fix #69638.

estebank · 2020-03-31T20:13:46Z

r? @Centril this is a bit of a hack, I'd love it if you could find ways to clean up this.

Centril

Some initial comments -- I can't say I followed everything on a first pass, but addressing these comments might help me.

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

Centril · 2020-04-02T12:51:28Z

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

+                        let pred = trait_ref.without_const().to_predicate().to_string();
+                        let pred = pred.replace(&impl_name, "T");
+                        let mut sugg = vec![
+                            match generics


Generally, I'd appreciate sprinkling more comments on the new code as its not clear what picture the parts are painting.

The explanation for what's going on here are in the match arms, namely figuring out whether there are type params already to add to them or suggest introducing type params. I think we might already have code for this elsewhere though.

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

eddyb · 2020-04-05T10:44:00Z

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

+                    ty::Param(param) => {
+                        // `fn foo(t: impl Trait)`
+                        //                 ^^^^^ get this string
+                        param
+                            .name
+                            .as_str()
+                            .strip_prefix("impl")
+                            .map(|s| (s.trim_start().to_string(), sig))
+                    }


Actually, looked at the whole diff, you have the hir::Generics, and you could either use that (tricky) or you could pass in the predicates_of for the item. Which, I think if you instantiate_identity, you get a flat list of all of the predicates in scope, and they should still have Spans.

You can presumably search for trait_ref in the list of predicate and get the corresponding Span.
Which should be exactly the Foo in impl Foo + Bar, that corresponds to the trait that's missing an associated type.

Bonus: you can probably use the Spans in predicates_of for other suggestions elsewhere - their initial purpose was automatically applicable suggestions for type aliases not being WF, back in late 2018, before that stuff fell through the f loor.

So I added span labels for each TraitPredicate, and this is what I got:

error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/test/ui/suggestions/impl-trait-with-missing-bounds.rs:6:13 | 4 | fn foo(constraints: impl Iterator) { | -------------- | | | | | Binder(TraitPredicate(<impl Iterator as std::iter::Iterator>)) NotConst | Binder(TraitPredicate(<impl Iterator as std::marker::Sized>)) NotConst 5 | for constraint in constraints { 6 | qux(constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` ... 27 | fn qux(_: impl std::fmt::Debug) {} | --- --------------- required by this bound in `qux` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` help: introduce a type parameter with a trait bound instead of using `impl Trait` | 4 | fn foo<T: Iterator>(constraints: T) where <T as std::iter::Iterator>::Item: std::fmt::Debug { | ^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

I can see how it could be useful for some things, but the problem I see is that because this is an assoc type bound instead of setting it a type we cannot use the sytnax impl Iterator<Item = Something>. These spans would be great for that, but in this case we need to sadly rely only on extending the where clause to <X as Iterator>::Item: Trait.

You have two options: switching to impl Iterator<Item = T> where T is a new type parameter and adding a T: Trait bound, or impl Iterator<Item: Trait>, although I'm not sure the latter works yet or when it will work and it's probably still unstable anyway.

Anyway I was commenting only on the approach of getting the trait bound from the ty::Param "name": my point is that you can get its definition and work with that, which lets you get the real snippet where impl Foo+Bar was written (and each Foo and Bar in that if you look in the predicates_of).

impl Iterator<Item: Trait>

Yeah, that's not valid today.

Anyway I was commenting only on the approach

I understand.

which lets you get the real snippet where impl Foo+Bar was written

The current output for a impl Foo + Bar case is the following:

error[E0277]: `<impl Iterator + std::fmt::Debug as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/test/ui/suggestions/impl-trait-with-missing-bounds.rs:37:13 | 37 | qux(constraint); | ^^^^^^^^^^ `<impl Iterator + std::fmt::Debug as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` ... 42 | fn qux(_: impl std::fmt::Debug) {} | --- --------------- required by this bound in `qux` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator + std::fmt::Debug as std::iter::Iterator>::Item` help: introduce a type parameter with a trait bound instead of using `impl Trait` | 35 | fn bak<T: Iterator + std::fmt::Debug>(constraints: T) where <T as std::iter::Iterator>::Item: std::fmt::Debug { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

We need the whole Foo + Bar for the type param T: Foo + Bar. The only place where having the span to Foo for its snippet could be useful as things stand now is for the suggestion message where we now use <impl Foo + Bar as Foo>::AssocType where we could say <_ as Foo>::AssocType instead, but I feel that leaving it as it is is reasonable.

I think suggesting fn foo<T: Debug>(constraints: impl Iterator<Item = T>) {} is reasonable, but at that point the only thing left is the tension between ease of implementation of the suggestion and stylistic preference. The later seems to be more stylistically preferable, but don't know what the code to suggest it will look like yet.

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

… r=Centril Handle `impl Trait` where `Trait` has an assoc type with missing bounds When encountering a type parameter that needs more bounds the trivial case is `T` `where T: Bound`, but it can also be an `impl Trait` param that needs to be decomposed to a type param for cleaner code. For example, given ```rust fn foo(constraints: impl Iterator) { for constraint in constraints { println!("{:?}", constraint); } } ``` the previous output was ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 1 | fn foo(constraints: impl Iterator) { | - help: consider further restricting the associated type: `where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug` 2 | for constraint in constraints { 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` ``` which is incorrect as `where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug` is not valid syntax nor would it restrict the positional `impl Iterator` parameter if it were. The output being introduced is ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` help: introduce a type parameter with a trait bound instead of using `impl Trait` | LL | fn foo<T: Iterator>(constraints: T) where <T as std::iter::Iterator>::Item: std::fmt::Debug { | ^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` This suggestion is correct and lead the user in the right direction: because you have an associated type restriction you can no longer use `impl Trait`, the only reasonable alternative is to introduce a named type parameter, bound by `Trait` and with a `where` binding on the associated type for the new type parameter `as Trait` for the missing bound. *Ideally*, we would want to suggest something like the following, but that is not valid syntax today ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` help: introduce a type parameter with a trait bound instead of using `impl Trait` | LL | fn foo(constraints: impl Iterator<Item: std::fmt::Debug>) { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` Fix rust-lang#69638.

Centril · 2020-04-10T23:50:11Z

Seems to have failed tests in #71012, @bors r-

Fix rust-lang#69638.

estebank · 2020-04-11T22:00:16Z

@bors r=Centril had to rebase and re-bless because of small change to error output in master

bors · 2020-04-11T22:00:17Z

📌 Commit 984aac6 has been approved by Centril

… r=Centril Handle `impl Trait` where `Trait` has an assoc type with missing bounds When encountering a type parameter that needs more bounds the trivial case is `T` `where T: Bound`, but it can also be an `impl Trait` param that needs to be decomposed to a type param for cleaner code. For example, given ```rust fn foo(constraints: impl Iterator) { for constraint in constraints { println!("{:?}", constraint); } } ``` the previous output was ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 1 | fn foo(constraints: impl Iterator) { | - help: consider further restricting the associated type: `where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug` 2 | for constraint in constraints { 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` ``` which is incorrect as `where <impl Iterator as std::iter::Iterator>::Item: std::fmt::Debug` is not valid syntax nor would it restrict the positional `impl Iterator` parameter if it were. The output being introduced is ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` help: introduce a type parameter with a trait bound instead of using `impl Trait` | LL | fn foo<T: Iterator>(constraints: T) where <T as std::iter::Iterator>::Item: std::fmt::Debug { | ^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` This suggestion is correct and lead the user in the right direction: because you have an associated type restriction you can no longer use `impl Trait`, the only reasonable alternative is to introduce a named type parameter, bound by `Trait` and with a `where` binding on the associated type for the new type parameter `as Trait` for the missing bound. *Ideally*, we would want to suggest something like the following, but that is not valid syntax today ``` error[E0277]: `<impl Iterator as std::iter::Iterator>::Item` doesn't implement `std::fmt::Debug` --> src/main.rs:3:26 | 3 | println!("{:?}", constraint); | ^^^^^^^^^^ `<impl Iterator as std::iter::Iterator>::Item` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `<impl Iterator as std::iter::Iterator>::Item` = note: required by `std::fmt::Debug::fmt` help: introduce a type parameter with a trait bound instead of using `impl Trait` | LL | fn foo(constraints: impl Iterator<Item: std::fmt::Debug>) { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` Fix rust-lang#69638.

bors · 2020-04-12T06:32:51Z

⌛ Testing commit 984aac6 with merge 32fb4dc...

bors · 2020-04-12T10:02:02Z

☀️ Test successful - checks-azure
Approved by: Centril
Pushing 32fb4dc to master...

rust-highfive · 2020-04-12T10:03:14Z

📣 Toolstate changed by #69707!

Tested on commit 32fb4dc.
Direct link to PR: #69707

🎉 rls on linux: test-fail → test-pass (cc @Xanewok).

@Xanewok

Tested on commit rust-lang/rust@32fb4dc. Direct link to PR: <rust-lang/rust#69707> 🎉 rls on linux: test-fail → test-pass (cc @Xanewok).

rust-highfive assigned matthewjasper Mar 4, 2020