Fix clippy::semicolon_if_nothing_returned lints

waywardmonkeys · waywardmonkeys · commit c5a2ea022160 · 2024-09-03T23:01:55.000+07:00
diff --git a/src/box2d.rs b/src/box2d.rs
@@ -375,16 +375,16 @@ where
         for point in points {
             let p = point.borrow();
             if p.x < min_x {
-                min_x = p.x
+                min_x = p.x;
             }
             if p.x > max_x {
-                max_x = p.x
+                max_x = p.x;
             }
             if p.y < min_y {
-                min_y = p.y
+                min_y = p.y;
             }
             if p.y > max_y {
-                max_y = p.y
+                max_y = p.y;
             }
         }
 
diff --git a/src/box3d.rs b/src/box3d.rs
@@ -342,22 +342,22 @@ where
         for point in points {
             let p = point.borrow();
             if p.x < min_x {
-                min_x = p.x
+                min_x = p.x;
             }
             if p.x > max_x {
-                max_x = p.x
+                max_x = p.x;
             }
             if p.y < min_y {
-                min_y = p.y
+                min_y = p.y;
             }
             if p.y > max_y {
-                max_y = p.y
+                max_y = p.y;
             }
             if p.z < min_z {
-                min_z = p.z
+                min_z = p.z;
             }
             if p.z > max_z {
-                max_z = p.z
+                max_z = p.z;
             }
         }
 
diff --git a/src/length.rs b/src/length.rs
@@ -273,7 +273,7 @@ impl<T: Mul, U> Mul<T> for Length<T, U> {
 impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Length<T, U> {
     #[inline]
     fn mul_assign(&mut self, scale: T) {
-        *self = *self * scale
+        *self = *self * scale;
     }
 }
 
@@ -291,7 +291,7 @@ impl<T: Div, U> Div<T> for Length<T, U> {
 impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Length<T, U> {
     #[inline]
     fn div_assign(&mut self, scale: T) {
-        *self = *self / scale
+        *self = *self / scale;
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -39,6 +39,7 @@
 //! foreign function interfaces (provided the underlying scalar type is also `repr(C)`).
 //!
 #![deny(unconditional_recursion)]
+#![warn(clippy::semicolon_if_nothing_returned)]
 
 pub use crate::angle::Angle;
 pub use crate::box2d::Box2D;
diff --git a/src/point.rs b/src/point.rs
@@ -590,7 +590,7 @@ impl<T: Add, U> Add<Vector2D<T, U>> for Point2D<T, U> {
 impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector2D<T, U>> for Point2D<T, U> {
     #[inline]
     fn add_assign(&mut self, other: Vector2D<T, U>) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -632,7 +632,7 @@ impl<T: Sub, U> Sub<Vector2D<T, U>> for Point2D<T, U> {
 impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Point2D<T, U> {
     #[inline]
     fn sub_assign(&mut self, other: Vector2D<T, U>) {
-        *self = *self - other
+        *self = *self - other;
     }
 }
 
@@ -648,7 +648,7 @@ impl<T: Copy + Mul, U> Mul<T> for Point2D<T, U> {
 impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Point2D<T, U> {
     #[inline]
     fn mul_assign(&mut self, scale: T) {
-        *self = *self * scale
+        *self = *self * scale;
     }
 }
 
@@ -681,7 +681,7 @@ impl<T: Copy + Div, U> Div<T> for Point2D<T, U> {
 impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Point2D<T, U> {
     #[inline]
     fn div_assign(&mut self, scale: T) {
-        *self = *self / scale
+        *self = *self / scale;
     }
 }
 
@@ -1424,7 +1424,7 @@ impl<T: Add, U> Add<Vector3D<T, U>> for Point3D<T, U> {
 impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector3D<T, U>> for Point3D<T, U> {
     #[inline]
     fn add_assign(&mut self, other: Vector3D<T, U>) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -1471,7 +1471,7 @@ impl<T: Sub, U> Sub<Vector3D<T, U>> for Point3D<T, U> {
 impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector3D<T, U>> for Point3D<T, U> {
     #[inline]
     fn sub_assign(&mut self, other: Vector3D<T, U>) {
-        *self = *self - other
+        *self = *self - other;
     }
 }
 
diff --git a/src/rect.rs b/src/rect.rs
@@ -905,7 +905,7 @@ mod tests {
                 }
                 y += 0.1;
             }
-            x += 0.1
+            x += 0.1;
         }
     }
 
diff --git a/src/scale.rs b/src/scale.rs
@@ -416,7 +416,7 @@ impl<T: Default, Src, Dst> Default for Scale<T, Src, Dst> {
 
 impl<T: Hash, Src, Dst> Hash for Scale<T, Src, Dst> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.hash(state)
+        self.0.hash(state);
     }
 }
 
diff --git a/src/vector.rs b/src/vector.rs
@@ -788,7 +788,7 @@ impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Self> for Vector2
 impl<T: Copy + Add<T, Output = T>, U> AddAssign for Vector2D<T, U> {
     #[inline]
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -804,7 +804,7 @@ impl<T: Sub, U> Sub for Vector2D<T, U> {
 impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Vector2D<T, U> {
     #[inline]
     fn sub_assign(&mut self, other: Self) {
-        *self = *self - other
+        *self = *self - other;
     }
 }
 
@@ -820,7 +820,7 @@ impl<T: Copy + Mul, U> Mul<T> for Vector2D<T, U> {
 impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Vector2D<T, U> {
     #[inline]
     fn mul_assign(&mut self, scale: T) {
-        *self = *self * scale
+        *self = *self * scale;
     }
 }
 
@@ -853,7 +853,7 @@ impl<T: Copy + Div, U> Div<T> for Vector2D<T, U> {
 impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Vector2D<T, U> {
     #[inline]
     fn div_assign(&mut self, scale: T) {
-        *self = *self / scale
+        *self = *self / scale;
     }
 }
 
@@ -1713,7 +1713,7 @@ impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Self> for Vector3
 impl<T: Copy + Add<T, Output = T>, U> AddAssign for Vector3D<T, U> {
     #[inline]
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -1729,7 +1729,7 @@ impl<T: Sub, U> Sub for Vector3D<T, U> {
 impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector3D<T, U>> for Vector3D<T, U> {
     #[inline]
     fn sub_assign(&mut self, other: Self) {
-        *self = *self - other
+        *self = *self - other;
     }
 }
 
@@ -1745,7 +1745,7 @@ impl<T: Copy + Mul, U> Mul<T> for Vector3D<T, U> {
 impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Vector3D<T, U> {
     #[inline]
     fn mul_assign(&mut self, scale: T) {
-        *self = *self * scale
+        *self = *self * scale;
     }
 }
 
@@ -1779,7 +1779,7 @@ impl<T: Copy + Div, U> Div<T> for Vector3D<T, U> {
 impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Vector3D<T, U> {
     #[inline]
     fn div_assign(&mut self, scale: T) {
-        *self = *self / scale
+        *self = *self / scale;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -375,16 +375,16 @@ where`
`375`	`375`	`for point in points {`
`376`	`376`	`let p = point.borrow();`
`377`	`377`	`if p.x < min_x {`
`378`		`- min_x = p.x`
	`378`	`+ min_x = p.x;`
`379`	`379`	`}`
`380`	`380`	`if p.x > max_x {`
`381`		`- max_x = p.x`
	`381`	`+ max_x = p.x;`
`382`	`382`	`}`
`383`	`383`	`if p.y < min_y {`
`384`		`- min_y = p.y`
	`384`	`+ min_y = p.y;`
`385`	`385`	`}`
`386`	`386`	`if p.y > max_y {`
`387`		`- max_y = p.y`
	`387`	`+ max_y = p.y;`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
Original file line number	Diff line number	Diff line change
`@@ -342,22 +342,22 @@ where`
`342`	`342`	`for point in points {`
`343`	`343`	`let p = point.borrow();`
`344`	`344`	`if p.x < min_x {`
`345`		`- min_x = p.x`
	`345`	`+ min_x = p.x;`
`346`	`346`	`}`
`347`	`347`	`if p.x > max_x {`
`348`		`- max_x = p.x`
	`348`	`+ max_x = p.x;`
`349`	`349`	`}`
`350`	`350`	`if p.y < min_y {`
`351`		`- min_y = p.y`
	`351`	`+ min_y = p.y;`
`352`	`352`	`}`
`353`	`353`	`if p.y > max_y {`
`354`		`- max_y = p.y`
	`354`	`+ max_y = p.y;`
`355`	`355`	`}`
`356`	`356`	`if p.z < min_z {`
`357`		`- min_z = p.z`
	`357`	`+ min_z = p.z;`
`358`	`358`	`}`
`359`	`359`	`if p.z > max_z {`
`360`		`- max_z = p.z`
	`360`	`+ max_z = p.z;`
`361`	`361`	`}`
`362`	`362`	`}`
`363`	`363`
Original file line number	Diff line number	Diff line change
`@@ -273,7 +273,7 @@ impl<T: Mul, U> Mul<T> for Length<T, U> {`
`273`	`273`	`impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Length<T, U> {`
`274`	`274`	`#[inline]`
`275`	`275`	`fn mul_assign(&mut self, scale: T) {`
`276`		`- self = self * scale`
	`276`	`+ self = self * scale;`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`
`@@ -291,7 +291,7 @@ impl<T: Div, U> Div<T> for Length<T, U> {`
`291`	`291`	`impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Length<T, U> {`
`292`	`292`	`#[inline]`
`293`	`293`	`fn div_assign(&mut self, scale: T) {`
`294`		`- self = self / scale`
	`294`	`+ self = self / scale;`
`295`	`295`	`}`
`296`	`296`	`}`
`297`	`297`
Original file line number	Diff line number	Diff line change
`@@ -590,7 +590,7 @@ impl<T: Add, U> Add<Vector2D<T, U>> for Point2D<T, U> {`
`590`	`590`	`impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector2D<T, U>> for Point2D<T, U> {`
`591`	`591`	`#[inline]`
`592`	`592`	`fn add_assign(&mut self, other: Vector2D<T, U>) {`
`593`		`- self = self + other`
	`593`	`+ self = self + other;`
`594`	`594`	`}`
`595`	`595`	`}`
`596`	`596`
`@@ -632,7 +632,7 @@ impl<T: Sub, U> Sub<Vector2D<T, U>> for Point2D<T, U> {`
`632`	`632`	`impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Point2D<T, U> {`
`633`	`633`	`#[inline]`
`634`	`634`	`fn sub_assign(&mut self, other: Vector2D<T, U>) {`
`635`		`- self = self - other`
	`635`	`+ self = self - other;`
`636`	`636`	`}`
`637`	`637`	`}`
`638`	`638`
`@@ -648,7 +648,7 @@ impl<T: Copy + Mul, U> Mul<T> for Point2D<T, U> {`
`648`	`648`	`impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Point2D<T, U> {`
`649`	`649`	`#[inline]`
`650`	`650`	`fn mul_assign(&mut self, scale: T) {`
`651`		`- self = self * scale`
	`651`	`+ self = self * scale;`
`652`	`652`	`}`
`653`	`653`	`}`
`654`	`654`
`@@ -681,7 +681,7 @@ impl<T: Copy + Div, U> Div<T> for Point2D<T, U> {`
`681`	`681`	`impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Point2D<T, U> {`
`682`	`682`	`#[inline]`
`683`	`683`	`fn div_assign(&mut self, scale: T) {`
`684`		`- self = self / scale`
	`684`	`+ self = self / scale;`
`685`	`685`	`}`
`686`	`686`	`}`
`687`	`687`
`@@ -1424,7 +1424,7 @@ impl<T: Add, U> Add<Vector3D<T, U>> for Point3D<T, U> {`
`1424`	`1424`	`impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector3D<T, U>> for Point3D<T, U> {`
`1425`	`1425`	`#[inline]`
`1426`	`1426`	`fn add_assign(&mut self, other: Vector3D<T, U>) {`
`1427`		`- self = self + other`
	`1427`	`+ self = self + other;`
`1428`	`1428`	`}`
`1429`	`1429`	`}`
`1430`	`1430`
`@@ -1471,7 +1471,7 @@ impl<T: Sub, U> Sub<Vector3D<T, U>> for Point3D<T, U> {`
`1471`	`1471`	`impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector3D<T, U>> for Point3D<T, U> {`
`1472`	`1472`	`#[inline]`
`1473`	`1473`	`fn sub_assign(&mut self, other: Vector3D<T, U>) {`
`1474`		`- self = self - other`
	`1474`	`+ self = self - other;`
`1475`	`1475`	`}`
`1476`	`1476`	`}`
`1477`	`1477`
Original file line number	Diff line number	Diff line change
`@@ -905,7 +905,7 @@ mod tests {`
`905`	`905`	`}`
`906`	`906`	`y += 0.1;`
`907`	`907`	`}`
`908`		`- x += 0.1`
	`908`	`+ x += 0.1;`
`909`	`909`	`}`
`910`	`910`	`}`
`911`	`911`
Original file line number	Diff line number	Diff line change
`@@ -416,7 +416,7 @@ impl<T: Default, Src, Dst> Default for Scale<T, Src, Dst> {`
`416`	`416`
`417`	`417`	`impl<T: Hash, Src, Dst> Hash for Scale<T, Src, Dst> {`
`418`	`418`	`fn hash<H: Hasher>(&self, state: &mut H) {`
`419`		`- self.0.hash(state)`
	`419`	`+ self.0.hash(state);`
`420`	`420`	`}`
`421`	`421`	`}`
`422`	`422`
Original file line number	Diff line number	Diff line change
`@@ -788,7 +788,7 @@ impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Self> for Vector2`
`788`	`788`	`impl<T: Copy + Add<T, Output = T>, U> AddAssign for Vector2D<T, U> {`
`789`	`789`	`#[inline]`
`790`	`790`	`fn add_assign(&mut self, other: Self) {`
`791`		`- self = self + other`
	`791`	`+ self = self + other;`
`792`	`792`	`}`
`793`	`793`	`}`
`794`	`794`
`@@ -804,7 +804,7 @@ impl<T: Sub, U> Sub for Vector2D<T, U> {`
`804`	`804`	`impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Vector2D<T, U> {`
`805`	`805`	`#[inline]`
`806`	`806`	`fn sub_assign(&mut self, other: Self) {`
`807`		`- self = self - other`
	`807`	`+ self = self - other;`
`808`	`808`	`}`
`809`	`809`	`}`
`810`	`810`
`@@ -820,7 +820,7 @@ impl<T: Copy + Mul, U> Mul<T> for Vector2D<T, U> {`
`820`	`820`	`impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Vector2D<T, U> {`
`821`	`821`	`#[inline]`
`822`	`822`	`fn mul_assign(&mut self, scale: T) {`
`823`		`- self = self * scale`
	`823`	`+ self = self * scale;`
`824`	`824`	`}`
`825`	`825`	`}`
`826`	`826`
`@@ -853,7 +853,7 @@ impl<T: Copy + Div, U> Div<T> for Vector2D<T, U> {`
`853`	`853`	`impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Vector2D<T, U> {`
`854`	`854`	`#[inline]`
`855`	`855`	`fn div_assign(&mut self, scale: T) {`
`856`		`- self = self / scale`
	`856`	`+ self = self / scale;`
`857`	`857`	`}`
`858`	`858`	`}`
`859`	`859`
`@@ -1713,7 +1713,7 @@ impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Self> for Vector3`
`1713`	`1713`	`impl<T: Copy + Add<T, Output = T>, U> AddAssign for Vector3D<T, U> {`
`1714`	`1714`	`#[inline]`
`1715`	`1715`	`fn add_assign(&mut self, other: Self) {`
`1716`		`- self = self + other`
	`1716`	`+ self = self + other;`
`1717`	`1717`	`}`
`1718`	`1718`	`}`
`1719`	`1719`
`@@ -1729,7 +1729,7 @@ impl<T: Sub, U> Sub for Vector3D<T, U> {`
`1729`	`1729`	`impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector3D<T, U>> for Vector3D<T, U> {`
`1730`	`1730`	`#[inline]`
`1731`	`1731`	`fn sub_assign(&mut self, other: Self) {`
`1732`		`- self = self - other`
	`1732`	`+ self = self - other;`
`1733`	`1733`	`}`
`1734`	`1734`	`}`
`1735`	`1735`
`@@ -1745,7 +1745,7 @@ impl<T: Copy + Mul, U> Mul<T> for Vector3D<T, U> {`
`1745`	`1745`	`impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Vector3D<T, U> {`
`1746`	`1746`	`#[inline]`
`1747`	`1747`	`fn mul_assign(&mut self, scale: T) {`
`1748`		`- self = self * scale`
	`1748`	`+ self = self * scale;`
`1749`	`1749`	`}`
`1750`	`1750`	`}`
`1751`	`1751`
`@@ -1779,7 +1779,7 @@ impl<T: Copy + Div, U> Div<T> for Vector3D<T, U> {`
`1779`	`1779`	`impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Vector3D<T, U> {`
`1780`	`1780`	`#[inline]`
`1781`	`1781`	`fn div_assign(&mut self, scale: T) {`
`1782`		`- self = self / scale`
	`1782`	`+ self = self / scale;`
`1783`	`1783`	`}`
`1784`	`1784`	`}`
`1785`	`1785`