Use the error variance for unused generic args

oli-obk · oli-obk · commit 026183d1efb1 · 2024-06-07T15:32:24.000Z
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1802,8 +1802,8 @@ fn receiver_is_implemented<'tcx>(
 pub fn check_variances_for_type_defn<'tcx>(
     tcx: TyCtxt<'tcx>,
     item: LocalDefId,
-    variances: &[ty::Variance],
-) -> Result<(), ErrorGuaranteed> {
+    variances: &'tcx [ty::Variance],
+) -> Result<&'tcx [ty::Variance], ErrorGuaranteed> {
     let identity_args = ty::GenericArgs::identity_for_item(tcx, item);
 
     match tcx.def_kind(item) {
@@ -1819,7 +1819,7 @@ pub fn check_variances_for_type_defn<'tcx>(
             );
             tcx.type_of(item).skip_binder().error_reported()?;
         }
-        _ => return Ok(()),
+        _ => return Ok(variances),
     }
 
     let ty_predicates = tcx.predicates_of(item);
@@ -1856,7 +1856,7 @@ pub fn check_variances_for_type_defn<'tcx>(
 
     let ty_generics = tcx.generics_of(item);
 
-    let mut res = Ok(());
+    let mut variances = variances;
 
     for (index, _) in variances.iter().enumerate() {
         let parameter = Parameter(index as u32);
@@ -1868,30 +1868,30 @@ pub fn check_variances_for_type_defn<'tcx>(
         let ty_param = &ty_generics.own_params[index];
         let hir_param = &hir_generics.params[index];
 
-        if ty_param.def_id != hir_param.def_id.into() {
+        let guar = if ty_param.def_id != hir_param.def_id.into() {
             // Valid programs always have lifetimes before types in the generic parameter list.
             // ty_generics are normalized to be in this required order, and variances are built
             // from ty generics, not from hir generics. but we need hir generics to get
             // a span out.
             //
             // If they aren't in the same order, then the user has written invalid code, and already
             // got an error about it (or I'm wrong about this).
-            tcx.dcx().span_delayed_bug(
-                hir_param.span,
-                "hir generics and ty generics in different order",
-            );
-            continue;
-        }
-
-        match hir_param.name {
-            hir::ParamName::Error(guar) => res = Err(guar),
-            _ => {
-                let has_explicit_bounds = explicitly_bounded_params.contains(&parameter);
-                res = Err(report_bivariance(tcx, hir_param, has_explicit_bounds, item));
+            tcx.dcx()
+                .span_delayed_bug(hir_param.span, "hir generics and ty generics in different order")
+        } else {
+            match hir_param.name {
+                hir::ParamName::Error(guar) => guar,
+                _ => {
+                    let has_explicit_bounds = explicitly_bounded_params.contains(&parameter);
+                    report_bivariance(tcx, hir_param, has_explicit_bounds, item)
+                }
             }
-        }
+        };
+        let mut v = variances.to_vec();
+        v[index] = ty::Variance::Errvariant(guar);
+        variances = tcx.arena.alloc_slice(&v);
     }
-    res
+    Ok(variances)
 }
 
 fn report_bivariance(
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -72,8 +72,10 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
         }
     };
 
-    let _ = crate::check::wfcheck::check_variances_for_type_defn(tcx, item_def_id, variances);
-    variances
+    match crate::check::wfcheck::check_variances_for_type_defn(tcx, item_def_id, variances) {
+        Ok(variances) => variances,
+        Err(guar) => tcx.arena.alloc_from_iter(variances.iter().map(|_| ty::Errvariant(guar))),
+    }
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]
diff --git a/compiler/rustc_infer/src/infer/relate/glb.rs b/compiler/rustc_infer/src/infer/relate/glb.rs
@@ -40,8 +40,10 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
         match variance {
             ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
             ty::Covariant => self.relate(a, b),
-            // TODO: report a new error kind
-            ty::Errvariant(_) => Ok(a),
+            ty::Errvariant(guar) => {
+                self.fields.infcx.set_tainted_by_errors(guar);
+                Ok(a)
+            }
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),
             ty::Contravariant => self.fields.lub().relate(a, b),
diff --git a/compiler/rustc_infer/src/infer/relate/lub.rs b/compiler/rustc_infer/src/infer/relate/lub.rs
@@ -40,8 +40,10 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
         match variance {
             ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
             ty::Covariant => self.relate(a, b),
-            // TODO: report a new kind of type error that preserves the `ErrorGuaranteed`?
-            ty::Errvariant(_) => Ok(a),
+            ty::Errvariant(guar) => {
+                self.fields.infcx.set_tainted_by_errors(guar);
+                Ok(a)
+            }
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),
             ty::Contravariant => self.fields.glb().relate(a, b),
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs
@@ -117,7 +117,11 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                     ty::Invariant => {
                         infcx.inner.borrow_mut().type_variables().equate(a_id, b_id);
                     }
-                    ty::Errvariant(_) | ty::Bivariant => {
+                    ty::Errvariant(guar) => {
+                        infcx.set_tainted_by_errors(guar);
+                        return Ok(Ty::new_error(self.tcx(), guar));
+                    }
+                    ty::Bivariant => {
                         unreachable!("Expected bivariance to be handled in relate_with_variance")
                     }
                 }
@@ -204,7 +208,11 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                     .unwrap_region_constraints()
                     .make_eqregion(origin, a, b);
             }
-            ty::Errvariant(_) | ty::Bivariant => {
+            ty::Errvariant(guar) => {
+                self.fields.infcx.set_tainted_by_errors(guar);
+                return Ok(ty::Region::new_error(self.tcx(), guar));
+            }
+            ty::Bivariant => {
                 unreachable!("Expected bivariance to be handled in relate_with_variance")
             }
         }
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-on-invalid-type.rs b/tests/ui/associated-consts/wrong-projection-self-ty-on-invalid-type.rs
@@ -0,0 +1,11 @@
+struct Fail<T>;
+//~^ ERROR: type parameter `T` is never used
+
+impl Fail<i32> {
+    const C: () = ();
+}
+
+fn main() {
+    Fail::<()>::C
+    //~^ ERROR: no associated item named `C` found for struct `Fail<()>`
+}
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-on-invalid-type.stderr b/tests/ui/associated-consts/wrong-projection-self-ty-on-invalid-type.stderr
@@ -0,0 +1,25 @@
+error[E0392]: type parameter `T` is never used
+  --> $DIR/wrong-projection-self-ty-on-invalid-type.rs:1:13
+   |
+LL | struct Fail<T>;
+   |             ^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
+
+error[E0599]: no associated item named `C` found for struct `Fail<()>` in the current scope
+  --> $DIR/wrong-projection-self-ty-on-invalid-type.rs:9:17
+   |
+LL | struct Fail<T>;
+   | -------------- associated item `C` not found for this struct
+...
+LL |     Fail::<()>::C
+   |                 ^ associated item not found in `Fail<()>`
+   |
+   = note: the associated item was found for
+           - `Fail<i32>`
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0392, E0599.
+For more information about an error, try `rustc --explain E0392`.
diff --git a/tests/ui/inference/dont-collect-stmts-from-parent-body.rs b/tests/ui/inference/dont-collect-stmts-from-parent-body.rs
@@ -8,7 +8,6 @@ fn main() {
         impl<T> Type<T> {
             fn new() -> Type<T> {
                 Type
-                //~^ ERROR type annotations needed
             }
         }
     };
diff --git a/tests/ui/inference/dont-collect-stmts-from-parent-body.stderr b/tests/ui/inference/dont-collect-stmts-from-parent-body.stderr
@@ -7,18 +7,6 @@ LL | struct Type<T>;
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
 
-error[E0282]: type annotations needed
-  --> $DIR/dont-collect-stmts-from-parent-body.rs:10:17
-   |
-LL |                 Type
-   |                 ^^^^ cannot infer type of the type parameter `T` declared on the struct `Type`
-   |
-help: consider specifying the generic argument
-   |
-LL |                 Type::<T>
-   |                     +++++
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0282, E0392.
-For more information about an error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0392`.
diff --git a/tests/ui/traits/trait-selection-ice-84727.rs b/tests/ui/traits/trait-selection-ice-84727.rs
@@ -20,6 +20,7 @@ where
 {
     fn over(self) -> Cell<NewFg> {
     //~^ ERROR mismatched types
+    //~| ERROR `over` has an incompatible type for trait
         self.over();
     }
 }
diff --git a/tests/ui/traits/trait-selection-ice-84727.stderr b/tests/ui/traits/trait-selection-ice-84727.stderr
@@ -17,7 +17,7 @@ LL |     Self: Over<Color<BottomBg>, Cell<NewFg>>,
    |                ^^^^^ not found in this scope
 
 error[E0412]: cannot find type `NewBg` in this scope
-  --> $DIR/trait-selection-ice-84727.rs:32:27
+  --> $DIR/trait-selection-ice-84727.rs:33:27
    |
 LL |     fn over(self) -> Cell<NewBg> {
    |                           ^^^^^ not found in this scope
@@ -27,21 +27,45 @@ help: you might be missing a type parameter
 LL | impl<'b, TopFg, TopBg, BottomFg, BottomBg, NewBg> Over<&Cell<BottomFg, BottomBg>, ()>
    |                                          +++++++
 
+error[E0053]: method `over` has an incompatible type for trait
+  --> $DIR/trait-selection-ice-84727.rs:21:22
+   |
+LL | impl<TopFg, TopBg, BottomFg, BottomBg, NewFg, NewBg>
+   |                                        -----  ----- expected type parameter
+   |                                        |
+   |                                        found type parameter
+...
+LL |     fn over(self) -> Cell<NewFg> {
+   |                      ^^^^^^^^^^^
+   |                      |
+   |                      expected type parameter `NewBg`, found type parameter `NewFg`
+   |                      help: change the output type to match the trait: `Cell<NewFg, NewBg>`
+   |
+note: type in trait
+  --> $DIR/trait-selection-ice-84727.rs:12:22
+   |
+LL |     fn over(self) -> Output;
+   |                      ^^^^^^
+   = note: expected signature `fn(Cell<_, _>) -> Cell<_, NewBg>`
+              found signature `fn(Cell<_, _>) -> Cell<_, NewFg>`
+   = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
+   = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
+
 error[E0308]: mismatched types
   --> $DIR/trait-selection-ice-84727.rs:21:22
    |
 LL |     fn over(self) -> Cell<NewFg> {
    |        ----          ^^^^^^^^^^^ expected `Cell<NewFg>`, found `()`
    |        |
    |        implicitly returns `()` as its body has no tail or `return` expression
-LL |
+...
 LL |         self.over();
    |                    - help: remove this semicolon to return this value
    |
    = note: expected struct `Cell<NewFg>`
            found unit type `()`
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-Some errors have detailed explanations: E0308, E0412.
-For more information about an error, try `rustc --explain E0308`.
+Some errors have detailed explanations: E0053, E0308, E0412.
+For more information about an error, try `rustc --explain E0053`.
diff --git a/tests/ui/variance/variance-regions-direct.rs b/tests/ui/variance/variance-regions-direct.rs
@@ -49,7 +49,7 @@ struct Test6<'a, 'b:'a> { //~ ERROR [+, o]
 // No uses at all is bivariant:
 
 #[rustc_variance]
-struct Test7<'a> { //~ ERROR [*]
+struct Test7<'a> { //~ ERROR [💥]
     //~^ ERROR: `'a` is never used
     x: isize
 }
diff --git a/tests/ui/variance/variance-regions-direct.stderr b/tests/ui/variance/variance-regions-direct.stderr
@@ -36,7 +36,7 @@ error: [+, o]
 LL | struct Test6<'a, 'b:'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*]
+error: [💥]
   --> $DIR/variance-regions-direct.rs:52:1
    |
 LL | struct Test7<'a> {
diff --git a/tests/ui/variance/variance-regions-indirect.rs b/tests/ui/variance/variance-regions-indirect.rs
@@ -5,27 +5,27 @@
 #![feature(rustc_attrs)]
 
 #[rustc_variance]
-enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR [-, +, o, *]
+enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR [-, +, o, 💥]
     //~^ ERROR: `'d` is never used
     Test8A(extern "Rust" fn(&'a isize)),
     Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),
 }
 
 #[rustc_variance]
-struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR [*, o, +, -]
+struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR [💥, o, +, -]
     //~^ ERROR: `'w` is never used
     f: Base<'z, 'y, 'x, 'w>
 }
 
 #[rustc_variance] // Combine - and + to yield o
-struct Derived2<'a, 'b:'a, 'c> { //~ ERROR [o, o, *]
+struct Derived2<'a, 'b:'a, 'c> { //~ ERROR [o, o, 💥]
     //~^ ERROR: `'c` is never used
     f: Base<'a, 'a, 'b, 'c>
 }
 
 #[rustc_variance] // Combine + and o to yield o (just pay attention to 'a here)
-struct Derived3<'a:'b, 'b, 'c> { //~ ERROR [o, +, *]
+struct Derived3<'a:'b, 'b, 'c> { //~ ERROR [o, +, 💥]
     //~^ ERROR: `'c` is never used
     f: Base<'a, 'b, 'a, 'c>
 }
diff --git a/tests/ui/variance/variance-regions-indirect.stderr b/tests/ui/variance/variance-regions-indirect.stderr
@@ -30,25 +30,25 @@ LL | struct Derived3<'a:'b, 'b, 'c> {
    |
    = help: consider removing `'c`, referring to it in a field, or using a marker such as `PhantomData`
 
-error: [-, +, o, *]
+error: [-, +, o, 💥]
   --> $DIR/variance-regions-indirect.rs:8:1
    |
 LL | enum Base<'a, 'b, 'c:'b, 'd> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, o, +, -]
+error: [💥, o, +, -]
   --> $DIR/variance-regions-indirect.rs:16:1
    |
 LL | struct Derived1<'w, 'x:'y, 'y, 'z> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, o, *]
+error: [o, o, 💥]
   --> $DIR/variance-regions-indirect.rs:22:1
    |
 LL | struct Derived2<'a, 'b:'a, 'c> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, +, *]
+error: [o, +, 💥]
   --> $DIR/variance-regions-indirect.rs:28:1
    |
 LL | struct Derived3<'a:'b, 'b, 'c> {
diff --git a/tests/ui/variance/variance-trait-bounds.rs b/tests/ui/variance/variance-trait-bounds.rs
@@ -18,19 +18,19 @@ struct TestStruct<U,T:Setter<U>> { //~ ERROR [+, +]
 }
 
 #[rustc_variance]
-enum TestEnum<U,T:Setter<U>> { //~ ERROR [*, +]
+enum TestEnum<U,T:Setter<U>> { //~ ERROR [💥, +]
     //~^ ERROR: `U` is never used
     Foo(T)
 }
 
 #[rustc_variance]
-struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [*, +]
+struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [💥, +]
     //~^ ERROR: `U` is never used
     t: T
 }
 
 #[rustc_variance]
-struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [*, +]
+struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [💥, +]
     //~^ ERROR: `U` is never used
     t: T
 }
diff --git a/tests/ui/variance/variance-trait-bounds.stderr b/tests/ui/variance/variance-trait-bounds.stderr
@@ -31,19 +31,19 @@ error: [+, +]
 LL | struct TestStruct<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [💥, +]
   --> $DIR/variance-trait-bounds.rs:21:1
    |
 LL | enum TestEnum<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [💥, +]
   --> $DIR/variance-trait-bounds.rs:27:1
    |
 LL | struct TestContraStruct<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [💥, +]
   --> $DIR/variance-trait-bounds.rs:33:1
    |
 LL | struct TestBox<U,T:Getter<U>+Setter<U>> {

Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,10 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {`
`72`	`72`	`}`
`73`	`73`	`};`
`74`	`74`
`75`		`- let _ = crate::check::wfcheck::check_variances_for_type_defn(tcx, item_def_id, variances);`
`76`		`- variances`
	`75`	`+ match crate::check::wfcheck::check_variances_for_type_defn(tcx, item_def_id, variances) {`
	`76`	`+ Ok(variances) => variances,`
	`77`	`+ Err(guar) => tcx.arena.alloc_from_iter(variances.iter().map(\|_\| ty::Errvariant(guar))),`
	`78`	`+ }`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`#[instrument(level = "trace", skip(tcx), ret)]`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,11 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`117`	`117`	`ty::Invariant => {`
`118`	`118`	`infcx.inner.borrow_mut().type_variables().equate(a_id, b_id);`
`119`	`119`	`}`
`120`		`- ty::Errvariant(_) \| ty::Bivariant => {`
	`120`	`+ ty::Errvariant(guar) => {`
	`121`	`+ infcx.set_tainted_by_errors(guar);`
	`122`	`+ return Ok(Ty::new_error(self.tcx(), guar));`
	`123`	`+ }`
	`124`	`+ ty::Bivariant => {`
`121`	`125`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`122`	`126`	`}`
`123`	`127`	`}`
`@@ -204,7 +208,11 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`204`	`208`	`.unwrap_region_constraints()`
`205`	`209`	`.make_eqregion(origin, a, b);`
`206`	`210`	`}`
`207`		`- ty::Errvariant(_) \| ty::Bivariant => {`
	`211`	`+ ty::Errvariant(guar) => {`
	`212`	`+ self.fields.infcx.set_tainted_by_errors(guar);`
	`213`	`+ return Ok(ty::Region::new_error(self.tcx(), guar));`
	`214`	`+ }`
	`215`	`+ ty::Bivariant => {`
`208`	`216`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`209`	`217`	`}`
`210`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ fn main() {`
`8`	`8`	`impl<T> Type<T> {`
`9`	`9`	`fn new() -> Type<T> {`
`10`	`10`	`Type`
`11`		`- //~^ ERROR type annotations needed`
`12`	`11`	`}`
`13`	`12`	`}`
`14`	`13`	`};`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ where`
`20`	`20`	`{`
`21`	`21`	`fn over(self) -> Cell<NewFg> {`
`22`	`22`	`//~^ ERROR mismatched types`
	`23`	+ //~\| ERROR `over` has an incompatible type for trait
`23`	`24`	`self.over();`
`24`	`25`	`}`
`25`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ struct Test6<'a, 'b:'a> { //~ ERROR [+, o]`
`49`	`49`	`// No uses at all is bivariant:`
`50`	`50`
`51`	`51`	`#[rustc_variance]`
`52`		`-struct Test7<'a> { //~ ERROR [*]`
	`52`	`+struct Test7<'a> { //~ ERROR [💥]`
`53`	`53`	//~^ ERROR: `'a` is never used
`54`	`54`	`x: isize`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ error: [+, o]`
`36`	`36`	`LL \| struct Test6<'a, 'b:'a> {`
`37`	`37`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`38`	`38`
`39`		`-error: [*]`
	`39`	`+error: [💥]`
`40`	`40`	`--> $DIR/variance-regions-direct.rs:52:1`
`41`	`41`	`\|`
`42`	`42`	`LL \| struct Test7<'a> {`
Original file line number	Diff line number	Diff line change
`@@ -30,25 +30,25 @@ LL \| struct Derived3<'a:'b, 'b, 'c> {`
`30`	`30`	`\|`
`31`	`31`	= help: consider removing `'c`, referring to it in a field, or using a marker such as `PhantomData`
`32`	`32`
`33`		`-error: [-, +, o, *]`
	`33`	`+error: [-, +, o, 💥]`
`34`	`34`	`--> $DIR/variance-regions-indirect.rs:8:1`
`35`	`35`	`\|`
`36`	`36`	`LL \| enum Base<'a, 'b, 'c:'b, 'd> {`
`37`	`37`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`38`	`38`
`39`		`-error: [*, o, +, -]`
	`39`	`+error: [💥, o, +, -]`
`40`	`40`	`--> $DIR/variance-regions-indirect.rs:16:1`
`41`	`41`	`\|`
`42`	`42`	`LL \| struct Derived1<'w, 'x:'y, 'y, 'z> {`
`43`	`43`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`44`	`44`
`45`		`-error: [o, o, *]`
	`45`	`+error: [o, o, 💥]`
`46`	`46`	`--> $DIR/variance-regions-indirect.rs:22:1`
`47`	`47`	`\|`
`48`	`48`	`LL \| struct Derived2<'a, 'b:'a, 'c> {`
`49`	`49`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`50`	`50`
`51`		`-error: [o, +, *]`
	`51`	`+error: [o, +, 💥]`
`52`	`52`	`--> $DIR/variance-regions-indirect.rs:28:1`
`53`	`53`	`\|`
`54`	`54`	`LL \| struct Derived3<'a:'b, 'b, 'c> {`
Original file line number	Diff line number	Diff line change
`@@ -18,19 +18,19 @@ struct TestStruct<U,T:Setter<U>> { //~ ERROR [+, +]`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`#[rustc_variance]`
`21`		`-enum TestEnum<U,T:Setter<U>> { //~ ERROR [*, +]`
	`21`	`+enum TestEnum<U,T:Setter<U>> { //~ ERROR [💥, +]`
`22`	`22`	//~^ ERROR: `U` is never used
`23`	`23`	`Foo(T)`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`#[rustc_variance]`
`27`		`-struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [*, +]`
	`27`	`+struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [💥, +]`
`28`	`28`	//~^ ERROR: `U` is never used
`29`	`29`	`t: T`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`#[rustc_variance]`
`33`		`-struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [*, +]`
	`33`	`+struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [💥, +]`
`34`	`34`	//~^ ERROR: `U` is never used
`35`	`35`	`t: T`
`36`	`36`	`}`