rust/src/test/ui/rfc1445/issue-62307-match-ref-ref-forbidden-without-eq.stderr

warning: to use a constant of type `&&B` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:31:9
   |
LL |         RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
   |         ^^^^^
   |
note: the lint level is defined here
  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:13:36
   |
LL | #![warn(indirect_structural_match, nontrivial_structural_match)]
   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
   = note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>

warning: to use a constant of type `&&B` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:38:9
   |
LL |         RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
   |         ^^^^^
   |
   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
   = note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>

warning: 2 warnings emitted
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			warning: to use a constant of type `&&B` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
Regression tests and updates to existing tests. The regression tests explore: (direct \| indirect \| doubly-indirect \| unsafe) x (embedded \| param): where: embedded: `struct Wrapper(... NoDerive ...);` param: `struct Wrapper<X>(... X ...);` direct: `const A: Wrapper<...> = Wrapper(NoDerive);` indirect: `const A: & & Wrapper<...> = Wrapper(NoDerive)` doubly-indirect: `const A: & & Wrapper<...> = & & Wrapper(& & NoDerive)` unsafe: `const A: UnsafeWrap<...> = UnsafeWrap(std::ptr::null())` 2019-07-03 09:54:08 -05:00			`--> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:31:9`
			`\|`
			`LL \| RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }`
			`\| ^^^^^`
			`\|`
Normalise notes with the/is 2020-01-22 17:57:38 -06:00			`note: the lint level is defined here`
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			`--> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:13:36`
Turn `indirect_structural_match` lint on explicitly in ui tests. 2019-07-12 08:27:21 -05:00			`\|`
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			`LL \| #![warn(indirect_structural_match, nontrivial_structural_match)]`
			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Regression tests and updates to existing tests. The regression tests explore: (direct \| indirect \| doubly-indirect \| unsafe) x (embedded \| param): where: embedded: `struct Wrapper(... NoDerive ...);` param: `struct Wrapper<X>(... X ...);` direct: `const A: Wrapper<...> = Wrapper(NoDerive);` indirect: `const A: & & Wrapper<...> = Wrapper(NoDerive)` doubly-indirect: `const A: & & Wrapper<...> = & & Wrapper(& & NoDerive)` unsafe: `const A: UnsafeWrap<...> = UnsafeWrap(std::ptr::null())` 2019-07-03 09:54:08 -05:00			`= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!`
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			`= note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>`
Regression tests and updates to existing tests. The regression tests explore: (direct \| indirect \| doubly-indirect \| unsafe) x (embedded \| param): where: embedded: `struct Wrapper(... NoDerive ...);` param: `struct Wrapper<X>(... X ...);` direct: `const A: Wrapper<...> = Wrapper(NoDerive);` indirect: `const A: & & Wrapper<...> = Wrapper(NoDerive)` doubly-indirect: `const A: & & Wrapper<...> = & & Wrapper(& & NoDerive)` unsafe: `const A: UnsafeWrap<...> = UnsafeWrap(std::ptr::null())` 2019-07-03 09:54:08 -05:00
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			warning: to use a constant of type `&&B` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
Regression tests and updates to existing tests. The regression tests explore: (direct \| indirect \| doubly-indirect \| unsafe) x (embedded \| param): where: embedded: `struct Wrapper(... NoDerive ...);` param: `struct Wrapper<X>(... X ...);` direct: `const A: Wrapper<...> = Wrapper(NoDerive);` indirect: `const A: & & Wrapper<...> = Wrapper(NoDerive)` doubly-indirect: `const A: & & Wrapper<...> = & & Wrapper(& & NoDerive)` unsafe: `const A: UnsafeWrap<...> = UnsafeWrap(std::ptr::null())` 2019-07-03 09:54:08 -05:00			`--> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:38:9`
			`\|`
			`LL \| RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }`
			`\| ^^^^^`
			`\|`
			`= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!`
Use precise errors during const to pat conversion instead of a catch-all on the main constant 2020-09-20 10:22:33 -05:00			`= note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>`
Regression tests and updates to existing tests. The regression tests explore: (direct \| indirect \| doubly-indirect \| unsafe) x (embedded \| param): where: embedded: `struct Wrapper(... NoDerive ...);` param: `struct Wrapper<X>(... X ...);` direct: `const A: Wrapper<...> = Wrapper(NoDerive);` indirect: `const A: & & Wrapper<...> = Wrapper(NoDerive)` doubly-indirect: `const A: & & Wrapper<...> = & & Wrapper(& & NoDerive)` unsafe: `const A: UnsafeWrap<...> = UnsafeWrap(std::ptr::null())` 2019-07-03 09:54:08 -05:00
rustc: Add a warning count upon completion 2020-03-11 10:30:09 -05:00			`warning: 2 warnings emitted`