error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:13:47
   |
LL |     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
   |                                               ^^^^^     ^^^^^
   |
note: the lint level is defined here
  --> $DIR/edition-lint-infer-outlives-multispan.rs:2:9
   |
LL | #![deny(explicit_outlives_requirements)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: remove these bounds
   |
LL -     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
LL +     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:18:61
   |
LL |     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
   |                                                             ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
LL +     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:23:53
   |
LL |     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
   |                                                     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
LL +     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:29:48
   |
LL |     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
   |                                                ^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
LL +     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:35:48
   |
LL |     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
   |                                                ^^^^          ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
LL +     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:41:46
   |
LL |     struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
   |                                              ^^^^    ^^^^^^^^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
LL +     struct TeeOutlivesAyYooWhereBee<'a, 'b, T, U> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:47:67
   |
LL |     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
   |                                                                   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
LL +     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:53:53
   |
LL |     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
   |                                                     ^^^^              ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
LL +     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:59:53
   |
LL |     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
   |                                                     ^^^^                   ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
LL +     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:65:69
   |
LL |     struct TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
   |                                                                     ^^^^^^^   ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
LL +     struct TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:71:69
   |
LL |     struct TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
   |                                                                     ^^^^^^^        ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
LL +     struct TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:77:38
   |
LL |     struct BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
   |                                      ^^^^   ^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
LL +     struct BeeOutlivesAyTeeBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:82:40
   |
LL |     struct BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
   |                                        ^^^^   ^^^^^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
LL +     struct BeeOutlivesAyTeeAyBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:87:55
   |
LL |     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
   |                                                       ^^^^     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
LL +     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:92:68
   |
LL |     struct BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
   |                                                                    ^^^^^^^^   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
LL +     struct BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:97:58
   |
LL |     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
   |                                                          ^^^^        ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
LL +     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:104:18
   |
LL |         where U: 'a + Debug + 'b, 'b: 'a
   |                  ^^^^^     ^^^^^  ^^^^^^
   |
help: remove these bounds
   |
LL -         where U: 'a + Debug + 'b, 'b: 'a
LL +         where U: Debug, 
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:115:47
   |
LL |     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b>(&'a &'b T);
   |                                               ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b>(&'a &'b T);
LL +     struct TeeOutlivesAyIsDebugBee<'a, 'b, T: Debug>(&'a &'b T);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:118:72
   |
LL |     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T>(&'a &'b T) where T: 'a + Debug + 'b;
   |                                                                        ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T>(&'a &'b T) where T: 'a + Debug + 'b;
LL +     struct TeeWhereOutlivesAyIsDebugBee<'a, 'b, T>(&'a &'b T) where T: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:121:53
   |
LL |     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b>(T, &'a &'b U);
   |                                                     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b>(T, &'a &'b U);
LL +     struct TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug>(T, &'a &'b U);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:124:48
   |
LL |     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug>(&'a T, &'b U);
   |                                                ^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug>(&'a T, &'b U);
LL +     struct TeeOutlivesAyYooBeeIsDebug<'a, 'b, T, U: Debug>(&'a T, &'b U);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:127:48
   |
LL |     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b>(&'a T, &'b U);
   |                                                ^^^^          ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b>(&'a T, &'b U);
LL +     struct TeeOutlivesAyYooIsDebugBee<'a, 'b, T, U: Debug>(&'a T, &'b U);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:130:46
   |
LL |     struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b;
   |                                              ^^^^                   ^^^^^^^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b;
LL +     struct TeeOutlivesAyYooWhereBee<'a, 'b, T, U>(&'a T, &'b U) ;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:133:81
   |
LL |     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U>(T, &'a &'b U) where U: 'a + Debug + 'b;
   |                                                                                 ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U>(T, &'a &'b U) where U: 'a + Debug + 'b;
LL +     struct TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U>(T, &'a &'b U) where U: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:136:53
   |
LL |     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b + Debug;
   |                                                     ^^^^                            ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b + Debug;
LL +     struct TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U>(&'a T, &'b U) where U: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:139:53
   |
LL |     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: Debug + 'b;
   |                                                     ^^^^                                 ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: Debug + 'b;
LL +     struct TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U>(&'a T, &'b U) where U: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:142:75
   |
LL |     struct TeeWhereAyYooWhereBeeIsDebug<'a, 'b, T, U>(&'a T, &'b U) where T: 'a, U: 'b + Debug;
   |                                                                           ^^^^^^^   ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereAyYooWhereBeeIsDebug<'a, 'b, T, U>(&'a T, &'b U) where T: 'a, U: 'b + Debug;
LL +     struct TeeWhereAyYooWhereBeeIsDebug<'a, 'b, T, U>(&'a T, &'b U) where U: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:145:75
   |
LL |     struct TeeWhereAyYooWhereIsDebugBee<'a, 'b, T, U>(&'a T, &'b U) where T: 'a, U: Debug + 'b;
   |                                                                           ^^^^^^^        ^^^^^
   |
help: remove these bounds
   |
LL -     struct TeeWhereAyYooWhereIsDebugBee<'a, 'b, T, U>(&'a T, &'b U) where T: 'a, U: Debug + 'b;
LL +     struct TeeWhereAyYooWhereIsDebugBee<'a, 'b, T, U>(&'a T, &'b U) where U: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:148:38
   |
LL |     struct BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b>(&'a &'b T);
   |                                      ^^^^   ^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b>(&'a &'b T);
LL +     struct BeeOutlivesAyTeeBee<'a, 'b, T>(&'a &'b T);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:151:40
   |
LL |     struct BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b>(&'a &'b T);
   |                                        ^^^^   ^^^^^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b>(&'a &'b T);
LL +     struct BeeOutlivesAyTeeAyBee<'a, 'b, T>(&'a &'b T);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:154:55
   |
LL |     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b>(&'a &'b T);
   |                                                       ^^^^     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b>(&'a &'b T);
LL +     struct BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b, T: Debug>(&'a &'b T);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:157:71
   |
LL |     struct BeeWhereAyTeeWhereAyIsDebugBee<'a, 'b, T>(&'a &'b T) where 'b: 'a, T: 'a + Debug + 'b;
   |                                                                       ^^^^^^^^   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeWhereAyTeeWhereAyIsDebugBee<'a, 'b, T>(&'a &'b T) where 'b: 'a, T: 'a + Debug + 'b;
LL +     struct BeeWhereAyTeeWhereAyIsDebugBee<'a, 'b, T>(&'a &'b T) where T: Debug;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:160:58
   |
LL |     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b>(T, &'a &'b U);
   |                                                          ^^^^        ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b>(T, &'a &'b U);
LL +     struct BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug>(T, &'a &'b U);
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:164:18
   |
LL |         where U: 'a + Debug + 'b, 'b: 'a;
   |                  ^^^^^     ^^^^^  ^^^^^^
   |
help: remove these bounds
   |
LL -         where U: 'a + Debug + 'b, 'b: 'a;
LL +         where U: Debug, ;
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:171:45
   |
LL |     enum TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
   |                                             ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
LL +     enum TeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:176:59
   |
LL |     enum TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
   |                                                           ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
LL +     enum TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:181:51
   |
LL |     enum TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
   |                                                   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
LL +     enum TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:187:46
   |
LL |     enum TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
   |                                              ^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
LL +     enum TeeOutlivesAyYooBeeIsDebug<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:193:46
   |
LL |     enum TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
   |                                              ^^^^          ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
LL +     enum TeeOutlivesAyYooIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:199:44
   |
LL |     enum TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
   |                                            ^^^^    ^^^^^^^^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
LL +     enum TeeOutlivesAyYooWhereBee<'a, 'b, T, U> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:205:65
   |
LL |     enum TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
   |                                                                 ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
LL +     enum TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:211:51
   |
LL |     enum TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
   |                                                   ^^^^              ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
LL +     enum TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:217:51
   |
LL |     enum TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
   |                                                   ^^^^                   ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
LL +     enum TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:223:67
   |
LL |     enum TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
   |                                                                   ^^^^^^^   ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
LL +     enum TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:229:67
   |
LL |     enum TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
   |                                                                   ^^^^^^^        ^^^^^
   |
help: remove these bounds
   |
LL -     enum TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
LL +     enum TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:235:36
   |
LL |     enum BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
   |                                    ^^^^   ^^^^
   |
help: remove these bounds
   |
LL -     enum BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
LL +     enum BeeOutlivesAyTeeBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:240:38
   |
LL |     enum BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
   |                                      ^^^^   ^^^^^^^^^
   |
help: remove these bounds
   |
LL -     enum BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
LL +     enum BeeOutlivesAyTeeAyBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:246:53
   |
LL |     enum BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
   |                                                     ^^^^     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
LL +     enum BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:251:66
   |
LL |     enum BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
   |                                                                  ^^^^^^^^   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
LL +     enum BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:256:56
   |
LL |     enum BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
   |                                                        ^^^^        ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     enum BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
LL +     enum BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:262:75
   |
LL |     enum BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b, 'b: 'a {
   |                                                                           ^^^^^     ^^^^^  ^^^^^^
   |
help: remove these bounds
   |
LL -     enum BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b, 'b: 'a {
LL +     enum BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: Debug,  {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:271:46
   |
LL |     union TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
   |                                              ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyIsDebugBee<'a, 'b, T: 'a + Debug + 'b> {
LL +     union TeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:276:60
   |
LL |     union TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
   |                                                            ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: 'a + Debug + 'b {
LL +     union TeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:281:52
   |
LL |     union TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
   |                                                    ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: 'a + Debug + 'b> {
LL +     union TeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:287:47
   |
LL |     union TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
   |                                               ^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyYooBeeIsDebug<'a, 'b, T: 'a, U: 'b + Debug> {
LL +     union TeeOutlivesAyYooBeeIsDebug<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:293:47
   |
LL |     union TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
   |                                               ^^^^          ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyYooIsDebugBee<'a, 'b, T: 'a, U: Debug + 'b> {
LL +     union TeeOutlivesAyYooIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:299:45
   |
LL |     union TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
   |                                             ^^^^    ^^^^^^^^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U> where U: 'b {
LL +     union TeeOutlivesAyYooWhereBee<'a, 'b, T, U> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:305:66
   |
LL |     union TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
   |                                                                  ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b {
LL +     union TeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:311:52
   |
LL |     union TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
   |                                                    ^^^^              ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T: 'a, U> where U: 'b + Debug {
LL +     union TeeOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:317:52
   |
LL |     union TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
   |                                                    ^^^^                   ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T: 'a, U> where U: Debug + 'b {
LL +     union TeeOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:323:68
   |
LL |     union TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
   |                                                                    ^^^^^^^   ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where T: 'a, U: 'b + Debug {
LL +     union TeeWhereOutlivesAyYooWhereBeeIsDebug<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:329:68
   |
LL |     union TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
   |                                                                    ^^^^^^^        ^^^^^
   |
help: remove these bounds
   |
LL -     union TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where T: 'a, U: Debug + 'b {
LL +     union TeeWhereOutlivesAyYooWhereIsDebugBee<'a, 'b, T, U> where U: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:335:37
   |
LL |     union BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
   |                                     ^^^^   ^^^^
   |
help: remove these bounds
   |
LL -     union BeeOutlivesAyTeeBee<'a, 'b: 'a, T: 'b> {
LL +     union BeeOutlivesAyTeeBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:340:39
   |
LL |     union BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
   |                                       ^^^^   ^^^^^^^^^
   |
help: remove these bounds
   |
LL -     union BeeOutlivesAyTeeAyBee<'a, 'b: 'a, T: 'a + 'b> {
LL +     union BeeOutlivesAyTeeAyBee<'a, 'b, T> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:345:54
   |
LL |     union BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
   |                                                      ^^^^     ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b: 'a, T: 'a + Debug + 'b> {
LL +     union BeeOutlivesAyTeeOutlivesAyIsDebugBee<'a, 'b, T: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:350:67
   |
LL |     union BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
   |                                                                   ^^^^^^^^   ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where 'b: 'a, T: 'a + Debug + 'b {
LL +     union BeeWhereAyTeeWhereOutlivesAyIsDebugBee<'a, 'b, T> where T: Debug {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:355:57
   |
LL |     union BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
   |                                                         ^^^^        ^^^^^     ^^^^^
   |
help: remove these bounds
   |
LL -     union BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b: 'a, T, U: 'a + Debug + 'b> {
LL +     union BeeOutlivesAyTeeYooOutlivesAyIsDebugBee<'a, 'b, T, U: Debug> {
   | 

error: outlives requirements can be inferred
  --> $DIR/edition-lint-infer-outlives-multispan.rs:361:76
   |
LL |     union BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b, 'b: 'a {
   |                                                                            ^^^^^     ^^^^^  ^^^^^^
   |
help: remove these bounds
   |
LL -     union BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: 'a + Debug + 'b, 'b: 'a {
LL +     union BeeWhereAyTeeYooWhereOutlivesAyIsDebugBee<'a, 'b, T, U> where U: Debug,  {
   | 

error: aborting due to 68 previous errors

