Fix ambiguous assert_eq uses

These uses of assert_eq will be broken by changes to how the prelude handles macros: rust-lang/rust#139493.

Author: PoignardAzur

gcode/src/gcode.rs

@@ -98,7 +98,9 @@ impl<A: Buffer<Word>> GCode<A> {
     }
 
     /// The overall category this [`GCode`] belongs to.
-    pub fn mnemonic(&self) -> Mnemonic { self.mnemonic }
+    pub fn mnemonic(&self) -> Mnemonic {
+        self.mnemonic
+    }
 
     /// The integral part of a command number (i.e. the `12` in `G12.3`).
     pub fn major_number(&self) -> u32 {
@@ -115,10 +117,14 @@ impl<A: Buffer<Word>> GCode<A> {
     }
 
     /// The arguments attached to this [`GCode`].
-    pub fn arguments(&self) -> &[Word] { self.arguments.as_slice() }
+    pub fn arguments(&self) -> &[Word] {
+        self.arguments.as_slice()
+    }
 
     /// Where the [`GCode`] was found in its source text.
-    pub fn span(&self) -> Span { self.span }
+    pub fn span(&self) -> Span {
+        self.span
+    }
 
     /// Add an argument to the list of arguments attached to this [`GCode`].
     pub fn push_argument(
@@ -252,7 +258,7 @@ mod tests {
             span: Span::default(),
         };
 
-        assert_eq!(code.major_number(), 90);
+        pretty_assertions::assert_eq!(code.major_number(), 90);
     }
 
     #[test]
@@ -265,7 +271,7 @@ mod tests {
                 span: Span::default(),
             };
 
-            assert_eq!(code.minor_number(), i);
+            pretty_assertions::assert_eq!(code.minor_number(), i);
         }
     }
 
@@ -290,9 +296,9 @@ mod tests {
         })
         .unwrap();
 
-        assert_eq!(code.value_for('X'), Some(10.0));
-        assert_eq!(code.value_for('x'), Some(10.0));
-        assert_eq!(code.value_for('Y'), Some(-3.5));
-        assert_eq!(code.value_for('Z'), None);
+        pretty_assertions::assert_eq!(code.value_for('X'), Some(10.0));
+        pretty_assertions::assert_eq!(code.value_for('x'), Some(10.0));
+        pretty_assertions::assert_eq!(code.value_for('Y'), Some(-3.5));
+        pretty_assertions::assert_eq!(code.value_for('Z'), None);
     }
 }

gcode/src/parser.rs

@@ -51,15 +51,19 @@ impl<'input, C, B> Parser<'input, C, B> {
 }
 
 impl<'input, B> From<&'input str> for Parser<'input, Nop, B> {
-    fn from(src: &'input str) -> Self { Parser::new(src, Nop) }
+    fn from(src: &'input str) -> Self {
+        Parser::new(src, Nop)
+    }
 }
 
 impl<'input, C: Callbacks, B: Buffers<'input>> Iterator
     for Parser<'input, C, B>
 {
     type Item = Line<'input, B>;
 
-    fn next(&mut self) -> Option<Self::Item> { self.lines.next() }
+    fn next(&mut self) -> Option<Self::Item> {
+        self.lines.next()
+    }
 }
 
 #[derive(Debug)]
@@ -306,32 +310,32 @@ mod tests {
         let src = "(this is a comment)";
         let got: Vec<_> = parse(src).collect();
 
-        assert_eq!(got.len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 1);
         let line = &got[0];
-        assert_eq!(line.comments().len(), 1);
-        assert_eq!(line.gcodes().len(), 0);
-        assert_eq!(line.span(), Span::new(0, src.len(), 0));
+        pretty_assertions::assert_eq!(line.comments().len(), 1);
+        pretty_assertions::assert_eq!(line.gcodes().len(), 0);
+        pretty_assertions::assert_eq!(line.span(), Span::new(0, src.len(), 0));
     }
 
     #[test]
     fn line_numbers() {
         let src = "N42";
         let got: Vec<_> = parse(src).collect();
 
-        assert_eq!(got.len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 1);
         let line = &got[0];
-        assert_eq!(line.comments().len(), 0);
-        assert_eq!(line.gcodes().len(), 0);
+        pretty_assertions::assert_eq!(line.comments().len(), 0);
+        pretty_assertions::assert_eq!(line.gcodes().len(), 0);
         let span = Span::new(0, src.len(), 0);
-        assert_eq!(
+        pretty_assertions::assert_eq!(
             line.line_number(),
             Some(Word {
                 letter: 'N',
                 value: 42.0,
                 span
             })
         );
-        assert_eq!(line.span(), span);
+        pretty_assertions::assert_eq!(line.span(), span);
     }
 
     #[test]
@@ -346,25 +350,25 @@ mod tests {
         )
         .collect();
 
-        assert_eq!(got.len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 1);
         assert!(got[0].line_number().is_none());
         let unexpected_line_number = unexpected_line_number.lock().unwrap();
-        assert_eq!(unexpected_line_number.len(), 1);
-        assert_eq!(unexpected_line_number[0].0, 42.0);
+        pretty_assertions::assert_eq!(unexpected_line_number.len(), 1);
+        pretty_assertions::assert_eq!(unexpected_line_number[0].0, 42.0);
     }
 
     #[test]
     fn parse_g90() {
         let src = "G90";
         let got: Vec<_> = parse(src).collect();
 
-        assert_eq!(got.len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 1);
         let line = &got[0];
-        assert_eq!(line.gcodes().len(), 1);
+        pretty_assertions::assert_eq!(line.gcodes().len(), 1);
         let g90 = &line.gcodes()[0];
-        assert_eq!(g90.major_number(), 90);
-        assert_eq!(g90.minor_number(), 0);
-        assert_eq!(g90.arguments().len(), 0);
+        pretty_assertions::assert_eq!(g90.major_number(), 90);
+        pretty_assertions::assert_eq!(g90.minor_number(), 0);
+        pretty_assertions::assert_eq!(g90.arguments().len(), 0);
     }
 
     #[test]
@@ -385,11 +389,11 @@ mod tests {
 
         let got: Vec<_> = parse(src).collect();
 
-        assert_eq!(got.len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 1);
         let line = &got[0];
-        assert_eq!(line.gcodes().len(), 1);
+        pretty_assertions::assert_eq!(line.gcodes().len(), 1);
         let g01 = &line.gcodes()[0];
-        assert_eq!(g01, &should_be);
+        pretty_assertions::assert_eq!(g01, &should_be);
     }
 
     #[test]
@@ -398,10 +402,10 @@ mod tests {
 
         let got: Vec<_> = parse(src).collect();
 
-        assert_eq!(got.len(), 2);
-        assert_eq!(got[0].gcodes().len(), 4);
-        assert_eq!(got[0].comments().len(), 1);
-        assert_eq!(got[1].gcodes().len(), 1);
+        pretty_assertions::assert_eq!(got.len(), 2);
+        pretty_assertions::assert_eq!(got[0].gcodes().len(), 4);
+        pretty_assertions::assert_eq!(got[0].comments().len(), 1);
+        pretty_assertions::assert_eq!(got[1].gcodes().len(), 1);
     }
 
     /// I wasn't sure if the `#[derive(Serialize)]` would work given we use
@@ -434,6 +438,6 @@ mod tests {
 
         let got: Vec<_> = crate::parse(src).collect();
 
-        assert_eq!(got, expected);
+        pretty_assertions::assert_eq!(got, expected);
     }
 }