Clean up lookup_op_method

sjwang05 · sjwang05 · commit 90af6f11f2b2 · 2023-11-29T18:21:57.000-08:00
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
@@ -865,12 +865,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     fn lookup_op_method(
         &self,
-        lhs: (&'tcx hir::Expr<'tcx>, Ty<'tcx>),
+        (lhs_expr, lhs_ty): (&'tcx hir::Expr<'tcx>, Ty<'tcx>),
         opt_rhs: Option<(&'tcx hir::Expr<'tcx>, Ty<'tcx>)>,
         op: Op,
         expected: Expectation<'tcx>,
     ) -> Result<MethodCallee<'tcx>, Vec<FulfillmentError<'tcx>>> {
-        let (lhs_expr, lhs_ty) = lhs;
         let span = match op {
             Op::Binary(op, _) => op.span,
             Op::Unary(_, span) => span,
diff --git a/tests/ui/binop/binary-op-suggest-deref.stderr b/tests/ui/binop/binary-op-suggest-deref.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/binary-op-suggest-deref.rs:8:12
+  --> $DIR/binary-op-suggest-deref.rs:6:12
    |
 LL |     if i < 0 {}
    |            ^ expected `&i64`, found integer
@@ -10,7 +10,7 @@ LL |     if *i < 0 {}
    |        +
 
 error[E0277]: can't compare `&&{integer}` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:17:13
+  --> $DIR/binary-op-suggest-deref.rs:15:13
    |
 LL |     _ = foo == 0;
    |             ^^ no implementation for `&&{integer} == {integer}`
@@ -32,7 +32,7 @@ LL |     _ = **foo == 0;
    |         ++
 
 error[E0277]: can't compare `&{integer}` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:19:13
+  --> $DIR/binary-op-suggest-deref.rs:17:13
    |
 LL |     _ = foo == &0;
    |             ^^ no implementation for `&{integer} == {integer}`
@@ -55,7 +55,7 @@ LL |     _ = *foo == &0;
    |         +
 
 error[E0277]: can't compare `&&&&&&{integer}` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:21:17
+  --> $DIR/binary-op-suggest-deref.rs:19:17
    |
 LL |     _ = &&&&foo == 0;
    |                 ^^ no implementation for `&&&&&&{integer} == {integer}`
@@ -78,7 +78,7 @@ LL +     _ = **foo == 0;
    |
 
 error[E0277]: can't compare `&{integer}` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:23:14
+  --> $DIR/binary-op-suggest-deref.rs:21:14
    |
 LL |     _ = *foo == 0;
    |              ^^ no implementation for `&{integer} == {integer}`
@@ -100,7 +100,7 @@ LL |     _ = **foo == 0;
    |         +
 
 error[E0277]: can't compare `&&{integer}` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:25:15
+  --> $DIR/binary-op-suggest-deref.rs:23:15
    |
 LL |     _ = &&foo == &&0;
    |               ^^ no implementation for `&&{integer} == {integer}`
@@ -126,7 +126,7 @@ LL +     _ = foo == &&0;
    |
 
 error[E0277]: can't compare `&Box<{integer}>` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:27:23
+  --> $DIR/binary-op-suggest-deref.rs:25:23
    |
 LL |     _ = &Box::new(42) == 42;
    |                       ^^ no implementation for `&Box<{integer}> == {integer}`
@@ -140,7 +140,7 @@ LL +     _ = *Box::new(42) == 42;
    |
 
 error[E0277]: can't compare `&Box<&Box<&{integer}>>` with `{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:29:35
+  --> $DIR/binary-op-suggest-deref.rs:27:35
    |
 LL |     _ = &Box::new(&Box::new(&42)) == 42;
    |                                   ^^ no implementation for `&Box<&Box<&{integer}>> == {integer}`
@@ -154,7 +154,7 @@ LL +     _ = ****Box::new(&Box::new(&42)) == 42;
    |
 
 error[E0277]: can't compare `{integer}` with `&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:33:11
+  --> $DIR/binary-op-suggest-deref.rs:31:11
    |
 LL |     _ = 0 == foo;
    |           ^^ no implementation for `{integer} == &&{integer}`
@@ -176,7 +176,7 @@ LL |     _ = 0 == **foo;
    |              ++
 
 error[E0277]: can't compare `{integer}` with `&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:35:12
+  --> $DIR/binary-op-suggest-deref.rs:33:12
    |
 LL |     _ = &0 == foo;
    |            ^^ no implementation for `{integer} == &{integer}`
@@ -199,7 +199,7 @@ LL |     _ = &0 == *foo;
    |               +
 
 error[E0277]: can't compare `{integer}` with `&&&&&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:37:11
+  --> $DIR/binary-op-suggest-deref.rs:35:11
    |
 LL |     _ = 0 == &&&&foo;
    |           ^^ no implementation for `{integer} == &&&&&&{integer}`
@@ -222,7 +222,7 @@ LL +     _ = 0 == **foo;
    |
 
 error[E0277]: can't compare `{integer}` with `&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:39:11
+  --> $DIR/binary-op-suggest-deref.rs:37:11
    |
 LL |     _ = 0 == *foo;
    |           ^^ no implementation for `{integer} == &{integer}`
@@ -244,7 +244,7 @@ LL |     _ = 0 == **foo;
    |              +
 
 error[E0277]: can't compare `{integer}` with `&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:41:13
+  --> $DIR/binary-op-suggest-deref.rs:39:13
    |
 LL |     _ = &&0 == &&foo;
    |             ^^ no implementation for `{integer} == &&{integer}`
@@ -270,7 +270,7 @@ LL +     _ = &&0 == foo;
    |
 
 error[E0277]: can't compare `Box<Box<{integer}>>` with `&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:45:33
+  --> $DIR/binary-op-suggest-deref.rs:43:33
    |
 LL |     _ = &Box::new(Box::new(42)) == &foo;
    |                                 ^^ no implementation for `Box<Box<{integer}>> == &&{integer}`
@@ -286,7 +286,7 @@ LL +     _ = **Box::new(Box::new(42)) == **foo;
    |
 
 error[E0277]: can't compare `Box<{integer}>` with `&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:47:23
+  --> $DIR/binary-op-suggest-deref.rs:45:23
    |
 LL |     _ = &Box::new(42) == &foo;
    |                       ^^ no implementation for `Box<{integer}> == &&{integer}`
@@ -302,7 +302,7 @@ LL +     _ = *Box::new(42) == **foo;
    |
 
 error[E0277]: can't compare `Box<Box<Box<Box<{integer}>>>>` with `&&{integer}`
-  --> $DIR/binary-op-suggest-deref.rs:49:53
+  --> $DIR/binary-op-suggest-deref.rs:47:53
    |
 LL |     _ = &Box::new(Box::new(Box::new(Box::new(42)))) == &foo;
    |                                                     ^^ no implementation for `Box<Box<Box<Box<{integer}>>>> == &&{integer}`
@@ -318,7 +318,7 @@ LL +     _ = ****Box::new(Box::new(Box::new(Box::new(42)))) == **foo;
    |
 
 error[E0277]: can't compare `&&{integer}` with `Box<Box<Box<Box<{integer}>>>>`
-  --> $DIR/binary-op-suggest-deref.rs:51:14
+  --> $DIR/binary-op-suggest-deref.rs:49:14
    |
 LL |     _ = &foo == &Box::new(Box::new(Box::new(Box::new(42))));
    |              ^^ no implementation for `&&{integer} == Box<Box<Box<Box<{integer}>>>>`
@@ -342,7 +342,7 @@ LL +     _ = **foo == ****Box::new(Box::new(Box::new(Box::new(42))));
    |
 
 error[E0308]: mismatched types
-  --> $DIR/binary-op-suggest-deref.rs:55:25
+  --> $DIR/binary-op-suggest-deref.rs:53:25
    |
 LL |     _ = Box::new(42) == 42;
    |         ------------    ^^ expected `Box<{integer}>`, found integer
@@ -358,7 +358,7 @@ LL |     _ = Box::new(42) == Box::new(42);
    |                         +++++++++  +
 
 error[E0277]: can't compare `&&{integer}` with `Foo`
-  --> $DIR/binary-op-suggest-deref.rs:60:13
+  --> $DIR/binary-op-suggest-deref.rs:58:13
    |
 LL |     _ = &&0 == Foo;
    |             ^^ no implementation for `&&{integer} == Foo`
@@ -376,15 +376,15 @@ LL |     _ = &&0 == Foo;
            and 6 others
 
 error[E0369]: binary operation `==` cannot be applied to type `Foo`
-  --> $DIR/binary-op-suggest-deref.rs:62:13
+  --> $DIR/binary-op-suggest-deref.rs:60:13
    |
 LL |     _ = Foo == &&0;
    |         --- ^^ --- &&{integer}
    |         |
    |         Foo
    |
 note: an implementation of `PartialEq<&&{integer}>` might be missing for `Foo`
-  --> $DIR/binary-op-suggest-deref.rs:59:5
+  --> $DIR/binary-op-suggest-deref.rs:57:5
    |
 LL |     struct Foo;
    |     ^^^^^^^^^^ must implement `PartialEq<&&{integer}>`
@@ -395,7 +395,7 @@ LL |     struct Foo;
    |
 
 error[E0277]: can't compare `&String` with `str`
-  --> $DIR/binary-op-suggest-deref.rs:71:20
+  --> $DIR/binary-op-suggest-deref.rs:69:20
    |
 LL |     _ = string_ref == partial[..3];
    |                    ^^ no implementation for `&String == str`
@@ -412,7 +412,7 @@ LL |     _ = *string_ref == partial[..3];
    |         +
 
 error[E0277]: can't compare `str` with `&String`
-  --> $DIR/binary-op-suggest-deref.rs:73:22
+  --> $DIR/binary-op-suggest-deref.rs:71:22
    |
 LL |     _ = partial[..3] == string_ref;
    |                      ^^ no implementation for `str == &String`
diff --git a/tests/ui/dst/issue-113447.stderr b/tests/ui/dst/issue-113447.stderr
@@ -1,5 +1,5 @@
 error[E0277]: can't compare `&[u8; 1]` with `[{integer}; 1]`
-  --> $DIR/issue-113447.rs:24:20
+  --> $DIR/issue-113447.rs:22:20
    |
 LL |     let _ = &[0u8] == [0xAA];
    |                    ^^ no implementation for `&[u8; 1] == [{integer}; 1]`

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error[E0308]: mismatched types`
`2`		`- --> $DIR/binary-op-suggest-deref.rs:8:12`
	`2`	`+ --> $DIR/binary-op-suggest-deref.rs:6:12`
`3`	`3`	`\|`
`4`	`4`	`LL \| if i < 0 {}`
`5`	`5`	\| ^ expected `&i64`, found integer
`@@ -10,7 +10,7 @@ LL \| if *i < 0 {}`
`10`	`10`	`\| +`
`11`	`11`
`12`	`12`	error[E0277]: can't compare `&&{integer}` with `{integer}`
`13`		`- --> $DIR/binary-op-suggest-deref.rs:17:13`
	`13`	`+ --> $DIR/binary-op-suggest-deref.rs:15:13`
`14`	`14`	`\|`
`15`	`15`	`LL \| _ = foo == 0;`
`16`	`16`	\| ^^ no implementation for `&&{integer} == {integer}`
`@@ -32,7 +32,7 @@ LL \| _ = **foo == 0;`
`32`	`32`	`\| ++`
`33`	`33`
`34`	`34`	error[E0277]: can't compare `&{integer}` with `{integer}`
`35`		`- --> $DIR/binary-op-suggest-deref.rs:19:13`
	`35`	`+ --> $DIR/binary-op-suggest-deref.rs:17:13`
`36`	`36`	`\|`
`37`	`37`	`LL \| _ = foo == &0;`
`38`	`38`	\| ^^ no implementation for `&{integer} == {integer}`
`@@ -55,7 +55,7 @@ LL \| _ = *foo == &0;`
`55`	`55`	`\| +`
`56`	`56`
`57`	`57`	error[E0277]: can't compare `&&&&&&{integer}` with `{integer}`
`58`		`- --> $DIR/binary-op-suggest-deref.rs:21:17`
	`58`	`+ --> $DIR/binary-op-suggest-deref.rs:19:17`
`59`	`59`	`\|`
`60`	`60`	`LL \| _ = &&&&foo == 0;`
`61`	`61`	\| ^^ no implementation for `&&&&&&{integer} == {integer}`
`@@ -78,7 +78,7 @@ LL + _ = **foo == 0;`
`78`	`78`	`\|`
`79`	`79`
`80`	`80`	error[E0277]: can't compare `&{integer}` with `{integer}`
`81`		`- --> $DIR/binary-op-suggest-deref.rs:23:14`
	`81`	`+ --> $DIR/binary-op-suggest-deref.rs:21:14`
`82`	`82`	`\|`
`83`	`83`	`LL \| _ = *foo == 0;`
`84`	`84`	\| ^^ no implementation for `&{integer} == {integer}`
`@@ -100,7 +100,7 @@ LL \| _ = **foo == 0;`
`100`	`100`	`\| +`
`101`	`101`
`102`	`102`	error[E0277]: can't compare `&&{integer}` with `{integer}`
`103`		`- --> $DIR/binary-op-suggest-deref.rs:25:15`
	`103`	`+ --> $DIR/binary-op-suggest-deref.rs:23:15`
`104`	`104`	`\|`
`105`	`105`	`LL \| _ = &&foo == &&0;`
`106`	`106`	\| ^^ no implementation for `&&{integer} == {integer}`
`@@ -126,7 +126,7 @@ LL + _ = foo == &&0;`
`126`	`126`	`\|`
`127`	`127`
`128`	`128`	error[E0277]: can't compare `&Box<{integer}>` with `{integer}`
`129`		`- --> $DIR/binary-op-suggest-deref.rs:27:23`
	`129`	`+ --> $DIR/binary-op-suggest-deref.rs:25:23`
`130`	`130`	`\|`
`131`	`131`	`LL \| _ = &Box::new(42) == 42;`
`132`	`132`	\| ^^ no implementation for `&Box<{integer}> == {integer}`
`@@ -140,7 +140,7 @@ LL + _ = *Box::new(42) == 42;`
`140`	`140`	`\|`
`141`	`141`
`142`	`142`	error[E0277]: can't compare `&Box<&Box<&{integer}>>` with `{integer}`
`143`		`- --> $DIR/binary-op-suggest-deref.rs:29:35`
	`143`	`+ --> $DIR/binary-op-suggest-deref.rs:27:35`
`144`	`144`	`\|`
`145`	`145`	`LL \| _ = &Box::new(&Box::new(&42)) == 42;`
`146`	`146`	\| ^^ no implementation for `&Box<&Box<&{integer}>> == {integer}`
`@@ -154,7 +154,7 @@ LL + _ = ****Box::new(&Box::new(&42)) == 42;`
`154`	`154`	`\|`
`155`	`155`
`156`	`156`	error[E0277]: can't compare `{integer}` with `&&{integer}`
`157`		`- --> $DIR/binary-op-suggest-deref.rs:33:11`
	`157`	`+ --> $DIR/binary-op-suggest-deref.rs:31:11`
`158`	`158`	`\|`
`159`	`159`	`LL \| _ = 0 == foo;`
`160`	`160`	\| ^^ no implementation for `{integer} == &&{integer}`
`@@ -176,7 +176,7 @@ LL \| _ = 0 == **foo;`
`176`	`176`	`\| ++`
`177`	`177`
`178`	`178`	error[E0277]: can't compare `{integer}` with `&{integer}`
`179`		`- --> $DIR/binary-op-suggest-deref.rs:35:12`
	`179`	`+ --> $DIR/binary-op-suggest-deref.rs:33:12`
`180`	`180`	`\|`
`181`	`181`	`LL \| _ = &0 == foo;`
`182`	`182`	\| ^^ no implementation for `{integer} == &{integer}`
`@@ -199,7 +199,7 @@ LL \| _ = &0 == *foo;`
`199`	`199`	`\| +`
`200`	`200`
`201`	`201`	error[E0277]: can't compare `{integer}` with `&&&&&&{integer}`
`202`		`- --> $DIR/binary-op-suggest-deref.rs:37:11`
	`202`	`+ --> $DIR/binary-op-suggest-deref.rs:35:11`
`203`	`203`	`\|`
`204`	`204`	`LL \| _ = 0 == &&&&foo;`
`205`	`205`	\| ^^ no implementation for `{integer} == &&&&&&{integer}`
`@@ -222,7 +222,7 @@ LL + _ = 0 == **foo;`
`222`	`222`	`\|`
`223`	`223`
`224`	`224`	error[E0277]: can't compare `{integer}` with `&{integer}`
`225`		`- --> $DIR/binary-op-suggest-deref.rs:39:11`
	`225`	`+ --> $DIR/binary-op-suggest-deref.rs:37:11`
`226`	`226`	`\|`
`227`	`227`	`LL \| _ = 0 == *foo;`
`228`	`228`	\| ^^ no implementation for `{integer} == &{integer}`
`@@ -244,7 +244,7 @@ LL \| _ = 0 == **foo;`
`244`	`244`	`\| +`
`245`	`245`
`246`	`246`	error[E0277]: can't compare `{integer}` with `&&{integer}`
`247`		`- --> $DIR/binary-op-suggest-deref.rs:41:13`
	`247`	`+ --> $DIR/binary-op-suggest-deref.rs:39:13`
`248`	`248`	`\|`
`249`	`249`	`LL \| _ = &&0 == &&foo;`
`250`	`250`	\| ^^ no implementation for `{integer} == &&{integer}`
`@@ -270,7 +270,7 @@ LL + _ = &&0 == foo;`
`270`	`270`	`\|`
`271`	`271`
`272`	`272`	error[E0277]: can't compare `Box<Box<{integer}>>` with `&&{integer}`
`273`		`- --> $DIR/binary-op-suggest-deref.rs:45:33`
	`273`	`+ --> $DIR/binary-op-suggest-deref.rs:43:33`
`274`	`274`	`\|`
`275`	`275`	`LL \| _ = &Box::new(Box::new(42)) == &foo;`
`276`	`276`	\| ^^ no implementation for `Box<Box<{integer}>> == &&{integer}`
`@@ -286,7 +286,7 @@ LL + _ = Box::new(Box::new(42)) == foo;`
`286`	`286`	`\|`
`287`	`287`
`288`	`288`	error[E0277]: can't compare `Box<{integer}>` with `&&{integer}`
`289`		`- --> $DIR/binary-op-suggest-deref.rs:47:23`
	`289`	`+ --> $DIR/binary-op-suggest-deref.rs:45:23`
`290`	`290`	`\|`
`291`	`291`	`LL \| _ = &Box::new(42) == &foo;`
`292`	`292`	\| ^^ no implementation for `Box<{integer}> == &&{integer}`
`@@ -302,7 +302,7 @@ LL + _ = Box::new(42) == *foo;`
`302`	`302`	`\|`
`303`	`303`
`304`	`304`	error[E0277]: can't compare `Box<Box<Box<Box<{integer}>>>>` with `&&{integer}`
`305`		`- --> $DIR/binary-op-suggest-deref.rs:49:53`
	`305`	`+ --> $DIR/binary-op-suggest-deref.rs:47:53`
`306`	`306`	`\|`
`307`	`307`	`LL \| _ = &Box::new(Box::new(Box::new(Box::new(42)))) == &foo;`
`308`	`308`	\| ^^ no implementation for `Box<Box<Box<Box<{integer}>>>> == &&{integer}`
`@@ -318,7 +318,7 @@ LL + _ = **Box::new(Box::new(Box::new(Box::new(42)))) == foo;`
`318`	`318`	`\|`
`319`	`319`
`320`	`320`	error[E0277]: can't compare `&&{integer}` with `Box<Box<Box<Box<{integer}>>>>`
`321`		`- --> $DIR/binary-op-suggest-deref.rs:51:14`
	`321`	`+ --> $DIR/binary-op-suggest-deref.rs:49:14`
`322`	`322`	`\|`
`323`	`323`	`LL \| _ = &foo == &Box::new(Box::new(Box::new(Box::new(42))));`
`324`	`324`	\| ^^ no implementation for `&&{integer} == Box<Box<Box<Box<{integer}>>>>`
`@@ -342,7 +342,7 @@ LL + _ = foo == **Box::new(Box::new(Box::new(Box::new(42))));`
`342`	`342`	`\|`
`343`	`343`
`344`	`344`	`error[E0308]: mismatched types`
`345`		`- --> $DIR/binary-op-suggest-deref.rs:55:25`
	`345`	`+ --> $DIR/binary-op-suggest-deref.rs:53:25`
`346`	`346`	`\|`
`347`	`347`	`LL \| _ = Box::new(42) == 42;`
`348`	`348`	\| ------------ ^^ expected `Box<{integer}>`, found integer
`@@ -358,7 +358,7 @@ LL \| _ = Box::new(42) == Box::new(42);`
`358`	`358`	`\| +++++++++ +`
`359`	`359`
`360`	`360`	error[E0277]: can't compare `&&{integer}` with `Foo`
`361`		`- --> $DIR/binary-op-suggest-deref.rs:60:13`
	`361`	`+ --> $DIR/binary-op-suggest-deref.rs:58:13`
`362`	`362`	`\|`
`363`	`363`	`LL \| _ = &&0 == Foo;`
`364`	`364`	\| ^^ no implementation for `&&{integer} == Foo`
`@@ -376,15 +376,15 @@ LL \| _ = &&0 == Foo;`
`376`	`376`	`and 6 others`
`377`	`377`
`378`	`378`	error[E0369]: binary operation `==` cannot be applied to type `Foo`
`379`		`- --> $DIR/binary-op-suggest-deref.rs:62:13`
	`379`	`+ --> $DIR/binary-op-suggest-deref.rs:60:13`
`380`	`380`	`\|`
`381`	`381`	`LL \| _ = Foo == &&0;`
`382`	`382`	`\| --- ^^ --- &&{integer}`
`383`	`383`	`\| \|`
`384`	`384`	`\| Foo`
`385`	`385`	`\|`
`386`	`386`	note: an implementation of `PartialEq<&&{integer}>` might be missing for `Foo`
`387`		`- --> $DIR/binary-op-suggest-deref.rs:59:5`
	`387`	`+ --> $DIR/binary-op-suggest-deref.rs:57:5`
`388`	`388`	`\|`
`389`	`389`	`LL \| struct Foo;`
`390`	`390`	\| ^^^^^^^^^^ must implement `PartialEq<&&{integer}>`
`@@ -395,7 +395,7 @@ LL \| struct Foo;`
`395`	`395`	`\|`
`396`	`396`
`397`	`397`	error[E0277]: can't compare `&String` with `str`
`398`		`- --> $DIR/binary-op-suggest-deref.rs:71:20`
	`398`	`+ --> $DIR/binary-op-suggest-deref.rs:69:20`
`399`	`399`	`\|`
`400`	`400`	`LL \| _ = string_ref == partial[..3];`
`401`	`401`	\| ^^ no implementation for `&String == str`
`@@ -412,7 +412,7 @@ LL \| _ = *string_ref == partial[..3];`
`412`	`412`	`\| +`
`413`	`413`
`414`	`414`	error[E0277]: can't compare `str` with `&String`
`415`		`- --> $DIR/binary-op-suggest-deref.rs:73:22`
	`415`	`+ --> $DIR/binary-op-suggest-deref.rs:71:22`
`416`	`416`	`\|`
`417`	`417`	`LL \| _ = partial[..3] == string_ref;`
`418`	`418`	\| ^^ no implementation for `str == &String`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0277]: can't compare `&[u8; 1]` with `[{integer}; 1]`
`2`		`- --> $DIR/issue-113447.rs:24:20`
	`2`	`+ --> $DIR/issue-113447.rs:22:20`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _ = &[0u8] == [0xAA];`
`5`	`5`	\| ^^ no implementation for `&[u8; 1] == [{integer}; 1]`