added must-use to many functions (#449)

codegen/templates/mat.rs.tera

@@ -1895,6 +1895,7 @@ impl {{ self_t }} {
 {% endif %}
 
     /// Multiplies two {{ nxn }} matrices.
+    #[must_use]
     #[inline]
     pub fn mul_mat{{ dim }}(&self, rhs: &Self) -> Self {
         {% if self_t == "Mat2" and is_sse2 %}
@@ -1944,6 +1945,7 @@ impl {{ self_t }} {
     }
 
     /// Adds two {{ nxn }} matrices.
+    #[must_use]
     #[inline]
     pub fn add_mat{{ dim }}(&self, rhs: &Self) -> Self {
         {% if self_t == "Mat2" and is_sse2 %}
@@ -1962,6 +1964,7 @@ impl {{ self_t }} {
     }
 
     /// Subtracts two {{ nxn }} matrices.
+    #[must_use]
     #[inline]
     pub fn sub_mat{{ dim }}(&self, rhs: &Self) -> Self {
         {% if self_t == "Mat2" and is_sse2 %}
@@ -1980,6 +1983,7 @@ impl {{ self_t }} {
     }
 
     /// Multiplies a {{ nxn }} matrix by a scalar.
+    #[must_use]
     #[inline]
     pub fn mul_scalar(&self, rhs: {{ scalar_t }}) -> Self {
         {% if self_t == "Mat2" and is_sse2 %}

codegen/templates/quat.rs.tera

@@ -652,6 +652,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     #[doc(alias = "mix")]
     pub fn lerp(self, end: Self, s: {{ scalar_t }}) -> Self {
@@ -714,6 +715,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     pub fn slerp(self, mut end: Self, s: {{ scalar_t }}) -> Self {
         // http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
@@ -832,6 +834,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     pub fn mul_quat(self, rhs: Self) -> Self {
         glam_assert!(self.is_normalized());

codegen/templates/swizzle_traits.rs.tera

@@ -27,16 +27,19 @@
         {% endif %}
 
         {% if dim == 4 %}
+        #[must_use]
         #[inline]
         fn xyzw(self) -> Self {
             self
         }
         {% elif dim == 3 %}
+        #[must_use]
         #[inline]
         fn xyz(self) -> Self {
             self
         }
         {% elif dim == 2 %}
+        #[must_use]
         #[inline]
         fn xy(self) -> Self {
             self

codegen/templates/vec.rs.tera

@@ -514,6 +514,7 @@ impl {{ self_t }} {
     }
 
     /// Returns a vector where every component is the dot product of `self` and `rhs`.
+    #[must_use]
     #[inline]
     pub fn dot_into_vec(self, rhs: Self) -> Self {
         {% if is_sse2 %}
@@ -529,6 +530,7 @@ impl {{ self_t }} {
 
 {% if dim == 3 %}
     /// Computes the cross product of `self` and `rhs`.
+    #[must_use]
     #[inline]
     pub fn cross(self, rhs: Self) -> Self {
         {% if is_scalar %}
@@ -572,6 +574,7 @@ impl {{ self_t }} {
     /// Returns a vector containing the minimum values for each element of `self` and `rhs`.
     ///
     /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.
+    #[must_use]
     #[inline]
     pub fn min(self, rhs: Self) -> Self {
         {% if is_scalar %}
@@ -592,6 +595,7 @@ impl {{ self_t }} {
     /// Returns a vector containing the maximum values for each element of `self` and `rhs`.
     ///
     /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.
+    #[must_use]
     #[inline]
     pub fn max(self, rhs: Self) -> Self {
         {% if is_scalar %}
@@ -616,6 +620,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `min` is greater than `max` when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     pub fn clamp(self, min: Self, max: Self) -> Self {
         glam_assert!(min.cmple(max).all(), "clamp: expected min <= max");
@@ -862,6 +867,7 @@ impl {{ self_t }} {
 
 {% if is_signed %}
     /// Returns a vector containing the absolute value of each element of `self`.
+    #[must_use]
     #[inline]
     pub fn abs(self) -> Self {
         {% if is_scalar %}
@@ -894,6 +900,7 @@ impl {{ self_t }} {
     ///  - `1` if the number is positive
     ///  - `-1` if the number is negative
     {%- endif %}
+    #[must_use]
     #[inline]
     pub fn signum(self) -> Self {
         {% if is_scalar %}
@@ -925,6 +932,7 @@ impl {{ self_t }} {
 
     {% if is_float %}
     /// Returns a vector with signs of `rhs` and the magnitudes of `self`.
+    #[must_use]
     #[inline]
     pub fn copysign(self, rhs: Self) -> Self {
         {% if is_scalar %}
@@ -1117,6 +1125,7 @@ impl {{ self_t }} {
     /// # Panics
     /// This function will panic if any `rhs` element is 0 or the division results in overflow.
     {%- endif %}
+    #[must_use]
     #[inline]
     pub fn div_euclid(self, rhs: Self) -> Self {
         Self::new(
@@ -1138,6 +1147,7 @@ impl {{ self_t }} {
     {%- endif %}
     ///
     /// [Euclidean division]: {{scalar_t}}::rem_euclid
+    #[must_use]
     #[inline]
     pub fn rem_euclid(self, rhs: Self) -> Self {
         Self::new(
@@ -1299,6 +1309,7 @@ impl {{ self_t }} {
 
     /// Returns a vector containing the nearest integer to a number for each element of `self`.
     /// Round half-way cases away from 0.0.
+    #[must_use]
     #[inline]
     pub fn round(self) -> Self {
         {% if is_scalar %}
@@ -1318,6 +1329,7 @@ impl {{ self_t }} {
 
     /// Returns a vector containing the largest integer less than or equal to a number for each
     /// element of `self`.
+    #[must_use]
     #[inline]
     pub fn floor(self) -> Self {
         {% if is_scalar %}
@@ -1337,6 +1349,7 @@ impl {{ self_t }} {
 
     /// Returns a vector containing the smallest integer greater than or equal to a number for
     /// each element of `self`.
+    #[must_use]
     #[inline]
     pub fn ceil(self) -> Self {
         {% if is_scalar %}
@@ -1356,6 +1369,7 @@ impl {{ self_t }} {
 
     /// Returns a vector containing the integer part each element of `self`. This means numbers are
     /// always truncated towards zero.
+    #[must_use]
     #[inline]
     pub fn trunc(self) -> Self {
         {% if is_scalar %}
@@ -1377,13 +1391,15 @@ impl {{ self_t }} {
     /// self.floor()`.
     ///
     /// Note that this is fast but not precise for large numbers.
+    #[must_use]
     #[inline]
     pub fn fract(self) -> Self {
         self - self.floor()
     }
 
     /// Returns a vector containing `e^self` (the exponential function) for each element of
     /// `self`.
+    #[must_use]
     #[inline]
     pub fn exp(self) -> Self {
         Self::new(
@@ -1394,6 +1410,7 @@ impl {{ self_t }} {
     }
 
     /// Returns a vector containing each element of `self` raised to the power of `n`.
+    #[must_use]
     #[inline]
     pub fn powf(self, n: {{ scalar_t }}) -> Self {
         Self::new(
@@ -1404,6 +1421,7 @@ impl {{ self_t }} {
     }
 
     /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`.
+    #[must_use]
     #[inline]
     pub fn recip(self) -> Self {
         {% if is_scalar %}
@@ -1427,6 +1445,7 @@ impl {{ self_t }} {
     /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly
     /// extrapolated.
     #[doc(alias = "mix")]
+    #[must_use]
     #[inline]
     pub fn lerp(self, rhs: Self, s: {{ scalar_t }}) -> Self {
         self + ((rhs - self) * s)
@@ -1451,6 +1470,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `min` is greater than `max` when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     pub fn clamp_length(self, min: {{ scalar_t }}, max: {{ scalar_t }}) -> Self {
         glam_assert!(min <= max);
@@ -1465,6 +1485,7 @@ impl {{ self_t }} {
     }
 
     /// Returns a vector with a length no more than `max`
+    #[must_use]
     pub fn clamp_length_max(self, max: {{ scalar_t }}) -> Self {
         let length_sq = self.length_squared();
         if length_sq > max * max {
@@ -1475,6 +1496,7 @@ impl {{ self_t }} {
     }
 
     /// Returns a vector with a length no less than `min`
+    #[must_use]
     pub fn clamp_length_min(self, min: {{ scalar_t }}) -> Self {
         let length_sq = self.length_squared();
         if length_sq < min * min {
@@ -1491,6 +1513,7 @@ impl {{ self_t }} {
     /// architecture has a dedicated fma CPU instruction. However, this is not always true,
     /// and will be heavily dependant on designing algorithms with specific target hardware in
     /// mind.
+    #[must_use]
     #[inline]
     pub fn mul_add(self, a: Self, b: Self) -> Self {
         {% if is_sse2 %}
@@ -1514,6 +1537,7 @@ impl {{ self_t }} {
     /// conjunction with the [`rotate()`][Self::rotate()] method, e.g.
     /// `{{ vec2_t }}::from_angle(PI).rotate({{ vec2_t }}::Y)` will create the vector `[-1, 0]`
     /// and rotate [`{{ vec2_t }}::Y`] around it returning `-{{ vec2_t }}::Y`.
+    #[must_use]
     #[inline]
     pub fn from_angle(angle: {{ scalar_t }}) -> Self {
         let (sin, cos) = math::sin_cos(angle);
@@ -1558,6 +1582,7 @@ impl {{ self_t }} {
     ///
     /// The output vector is not necessarily unit length. For that use
     /// [`Self::any_orthonormal_vector()`] instead.
+    #[must_use]
     #[inline]
     pub fn any_orthogonal_vector(&self) -> Self {
         // This can probably be optimized
@@ -1575,6 +1600,7 @@ impl {{ self_t }} {
     /// # Panics
     ///
     /// Will panic if `self` is not normalized when `glam_assert` is enabled.
+    #[must_use]
     #[inline]
     pub fn any_orthonormal_vector(&self) -> Self {
         glam_assert!(self.is_normalized());
@@ -1608,6 +1634,7 @@ impl {{ self_t }} {
 
 {% if is_signed and dim == 2 %}
     /// Returns a vector that is equal to `self` rotated by 90 degrees.
+    #[must_use]
     #[inline]
     pub fn perp(self) -> Self {
         Self {

src/f32/coresimd/mat2.rs

@@ -238,6 +238,7 @@ impl Mat2 {
     }
 
     /// Multiplies two 2x2 matrices.
+    #[must_use]
     #[inline]
     pub fn mul_mat2(&self, rhs: &Self) -> Self {
         let abcd = self.0;
@@ -253,18 +254,21 @@ impl Mat2 {
     }
 
     /// Adds two 2x2 matrices.
+    #[must_use]
     #[inline]
     pub fn add_mat2(&self, rhs: &Self) -> Self {
         Self(self.0 + rhs.0)
     }
 
     /// Subtracts two 2x2 matrices.
+    #[must_use]
     #[inline]
     pub fn sub_mat2(&self, rhs: &Self) -> Self {
         Self(self.0 - rhs.0)
     }
 
     /// Multiplies a 2x2 matrix by a scalar.
+    #[must_use]
     #[inline]
     pub fn mul_scalar(&self, rhs: f32) -> Self {
         Self(self.0 * f32x4::splat(rhs))

src/f32/coresimd/mat3a.rs

@@ -486,6 +486,7 @@ impl Mat3A {
     }
 
     /// Multiplies two 3x3 matrices.
+    #[must_use]
     #[inline]
     pub fn mul_mat3(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -496,6 +497,7 @@ impl Mat3A {
     }
 
     /// Adds two 3x3 matrices.
+    #[must_use]
     #[inline]
     pub fn add_mat3(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -506,6 +508,7 @@ impl Mat3A {
     }
 
     /// Subtracts two 3x3 matrices.
+    #[must_use]
     #[inline]
     pub fn sub_mat3(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -516,6 +519,7 @@ impl Mat3A {
     }
 
     /// Multiplies a 3x3 matrix by a scalar.
+    #[must_use]
     #[inline]
     pub fn mul_scalar(&self, rhs: f32) -> Self {
         Self::from_cols(

src/f32/coresimd/mat4.rs

@@ -1107,6 +1107,7 @@ impl Mat4 {
     }
 
     /// Multiplies two 4x4 matrices.
+    #[must_use]
     #[inline]
     pub fn mul_mat4(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -1118,6 +1119,7 @@ impl Mat4 {
     }
 
     /// Adds two 4x4 matrices.
+    #[must_use]
     #[inline]
     pub fn add_mat4(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -1129,6 +1131,7 @@ impl Mat4 {
     }
 
     /// Subtracts two 4x4 matrices.
+    #[must_use]
     #[inline]
     pub fn sub_mat4(&self, rhs: &Self) -> Self {
         Self::from_cols(
@@ -1140,6 +1143,7 @@ impl Mat4 {
     }
 
     /// Multiplies a 4x4 matrix by a scalar.
+    #[must_use]
     #[inline]
     pub fn mul_scalar(&self, rhs: f32) -> Self {
         Self::from_cols(