lint: fix clippy::return_self_not_must_use

Author: magistau

Cargo.toml

@@ -21,7 +21,6 @@ inline_always = "allow"  # TODO: benchmark inlines
 missing_panics_doc = "allow"  # TODO
 similar_names = "allow"  # 26
 float_cmp = "allow"  # 42
-return_self_not_must_use = "allow"  # 63
 needless_pass_by_value = "allow"  # 70
 redundant_closure_for_method_calls = "allow"  # 76
 items_after_statements = "allow"  # 81

parser/src/ast.rs

@@ -857,6 +857,7 @@ impl From<Result<Complex, String>> for NumWord {
 
 impl NumWord {
     /// Map the number
+    #[must_use]
     pub fn map<R, C>(self, real: impl FnOnce(f64) -> R, complex: impl FnOnce(Complex) -> C) -> Self
     where
         C: Into<Self>,
@@ -869,6 +870,7 @@ impl NumWord {
         }
     }
     /// Map the number with another
+    #[must_use]
     pub fn map_with<R, C>(
         self,
         other: Self,

parser/src/complex.rs

@@ -48,6 +48,7 @@ impl Complex {
         Self { re, im }
     }
     /// Get the minimum of the real and imaginary parts of two complex numbers, ignoring NaN
+    #[must_use]
     pub fn min(self, rhs: impl Into<Self>) -> Self {
         let rhs = rhs.into();
         Self {
@@ -56,6 +57,7 @@ impl Complex {
         }
     }
     /// Get the maximum of the real and imaginary parts of two complex numbers, ignoring NaN
+    #[must_use]
     pub fn max(self, rhs: impl Into<Self>) -> Self {
         let rhs = rhs.into();
         Self {
@@ -64,20 +66,23 @@ impl Complex {
         }
     }
     /// Get the floor of the real and imaginary parts of a complex number
+    #[must_use]
     pub fn floor(self) -> Self {
         Self {
             re: self.re.floor(),
             im: self.im.floor(),
         }
     }
     /// Get the ceiling of the real and imaginary parts of a complex number
+    #[must_use]
     pub fn ceil(self) -> Self {
         Self {
             re: self.re.ceil(),
             im: self.im.ceil(),
         }
     }
     /// Round the real and imaginary parts of a complex number
+    #[must_use]
     pub fn round(self) -> Self {
         Self {
             re: self.re.round(),
@@ -90,12 +95,14 @@ impl Complex {
         (self.re * self.re + self.im * self.im).sqrt()
     }
     /// Get the arctangent of a complex number
+    #[must_use]
     pub fn atan2(self, x: impl Into<Self>) -> Complex {
         let y = self;
         let x = x.into();
         -Complex::I * ((x + Complex::I * y) / (y * y + x * x).sqrt()).ln()
     }
     /// Normalize a complex number
+    #[must_use]
     pub fn normalize(self) -> Self {
         let len = self.abs();
         if len == 0.0 {
@@ -117,6 +124,7 @@ impl Complex {
         r * Self::new(theta.cos(), theta.sin())
     }
     /// Raise a complex number to a complex power
+    #[must_use]
     pub fn powc(self, power: impl Into<Self>) -> Self {
         let power = power.into();
         if power.im == 0.0 {
@@ -126,6 +134,7 @@ impl Complex {
         ((r.ln() + Self::I * theta) * power).exp()
     }
     /// Raise a complex number to a real power
+    #[must_use]
     pub fn powf(self, power: f64) -> Self {
         if power == 0.0 {
             return Self::ONE;
@@ -137,20 +146,24 @@ impl Complex {
         Self::from_polar(r.powf(power), theta * power)
     }
     /// Calculate the exponential of a complex number
+    #[must_use]
     pub fn exp(self) -> Self {
         Self::from_polar(E.powf(self.re), self.im)
     }
     /// Calculate the natural logarithm of a complex number
+    #[must_use]
     pub fn ln(self) -> Self {
         let (r, theta) = self.to_polar();
         Self::new(r.ln(), theta)
     }
     /// Calculate the logarithm of a complex number
+    #[must_use]
     pub fn log(self, base: impl Into<Self>) -> Self {
         let base = base.into();
         Self::new(self.abs().ln(), self.arg()) / (Self::new(base.abs().ln(), base.arg()))
     }
     /// Calculate the square root of a complex number
+    #[must_use]
     pub fn sqrt(self) -> Self {
         if self.im == 0.0 {
             return if self.re >= 0.0 {
@@ -163,24 +176,28 @@ impl Complex {
         Self::from_polar(r.sqrt(), theta / 2.0)
     }
     /// Calculate the sine of a complex number
+    #[must_use]
     pub fn sin(self) -> Self {
         Self::new(
             self.re.sin() * self.im.cosh(),
             self.re.cos() * self.im.sinh(),
         )
     }
     /// Calculate the cosine of a complex number
+    #[must_use]
     pub fn cos(self) -> Self {
         Self::new(
             self.re.cos() * self.im.cosh(),
             -self.re.sin() * self.im.sinh(),
         )
     }
     /// Calculate the arc sine of a complex number
+    #[must_use]
     pub fn asin(self) -> Self {
         -Self::I * ((Self::ONE - self * self).sqrt() + Self::I * self).ln()
     }
     /// Calculate the arc cosine of a complex number
+    #[must_use]
     pub fn acos(self) -> Self {
         -Self::I * (Self::I * (Self::ONE - self * self).sqrt() + self).ln()
     }
@@ -197,13 +214,15 @@ impl Complex {
         }
     }
     /// Multiply by another complex number, with 0 × ∞ = 0
+    #[must_use]
     pub fn safe_mul(self, rhs: impl Into<Self>) -> Self {
         let rhs = rhs.into();
         Self {
             re: safe_mul(self.re, rhs.re) - safe_mul(self.im, rhs.im),
             im: safe_mul(self.re, rhs.im) + safe_mul(self.im, rhs.re),
         }
     }
+    #[must_use]
     pub fn recip(self) -> Self {
         Self::ONE / self
     }

parser/src/error.rs

@@ -139,6 +139,7 @@ impl Report {
     /// Change whether to color the report with ANSI escape codes when converting it to a string
     ///
     /// Defaults to `true`
+    #[must_use]
     pub fn color(mut self, color: bool) -> Self {
         self.color = color;
         self

parser/src/lex.rs

@@ -168,6 +168,7 @@ impl Span {
         Sp { value, span: self }
     }
     /// Merge two spans
+    #[must_use]
     pub fn merge(self, other: Self) -> Self {
         match (self, other) {
             (Span::Code(a), Span::Code(b)) => Span::Code(a.merge(b)),
@@ -396,6 +397,7 @@ impl CodeSpan {
         self.end.char_pos.saturating_sub(self.start.char_pos)
     }
     /// Merge two spans
+    #[must_use]
     pub fn merge(mut self, end: Self) -> Self {
         self.merge_with(end);
         self
@@ -406,6 +408,7 @@ impl CodeSpan {
         self.end = self.end.max(end.end);
     }
     /// Get the span between this span and another after it
+    #[must_use]
     pub fn end_to(self, other: &Self) -> Self {
         CodeSpan {
             start: self.end,
@@ -458,6 +461,7 @@ impl CodeSpan {
         inputs.try_get_with(&self.src, |input| f(&input[self.byte_range()]))
     }
     /// Get just the span of the first character
+    #[must_use]
     pub fn just_start(&self, inputs: &Inputs) -> Self {
         let start = self.start;
         let mut end = self.start;
@@ -473,6 +477,7 @@ impl CodeSpan {
         }
     }
     /// Get just the span of the last character
+    #[must_use]
     pub fn just_end(&self, inputs: &Inputs) -> Self {
         let end = self.end;
         let mut start = self.end;

parser/src/signature.rs

@@ -39,6 +39,7 @@ impl Signature {
         }
     }
     /// Set the number of arguments and outputs of the under stack
+    #[must_use]
     pub fn with_under(self, under_args: usize, under_outputs: usize) -> Self {
         Self {
             args: self.args,
@@ -108,6 +109,7 @@ impl Signature {
         self.is_compatible_with(other) && self.args <= other.args
     }
     /// Get the signature that has the maximum of the arguments and outputs of this signature and another
+    #[must_use]
     pub fn max_with(self, other: Self) -> Self {
         Self::new(
             self.args().max(other.args()),
@@ -119,6 +121,7 @@ impl Signature {
         )
     }
     /// Compose signatures as if a function with signature `other` was called before a function with signature `self`
+    #[must_use]
     pub fn compose(self, other: Self) -> Self {
         let args = other.args() + self.args().saturating_sub(other.outputs());
         let outputs = self.outputs() + other.outputs().saturating_sub(self.args());
@@ -129,6 +132,7 @@ impl Signature {
         Self::new(args, outputs).with_under(under_args, under_outputs)
     }
     /// Get the un-inverse of this signature
+    #[must_use]
     pub fn inverse(self) -> Self {
         Self::new(self.outputs(), self.args())
     }
@@ -140,6 +144,7 @@ impl Signature {
         Some(Signature::new(self.outputs() + 1, self.args() - 1))
     }
     /// The signature on the under stack
+    #[must_use]
     pub fn under(self) -> Signature {
         Signature::new(self.under_args(), self.under_outputs())
     }

src/algorithm/dyadic/combine.rs

@@ -113,6 +113,7 @@ impl Value {
     ///
     /// # Panics
     /// Panics if the arrays have incompatible shapes
+    #[must_use]
     pub fn join_infallible(self, other: Self, allow_ext: bool) -> Self {
         self.join_impl(other, allow_ext, &()).unwrap()
     }
@@ -233,6 +234,7 @@ impl<T: ArrayValue> Array<T> {
     ///
     /// # Panics
     /// Panics if the arrays have incompatible shapes
+    #[must_use]
     pub fn join_infallible(self, other: Self, allow_ext: bool) -> Self {
         self.join_impl(other, allow_ext, &()).unwrap()
     }
@@ -767,6 +769,7 @@ impl Value {
     ///
     /// # Panics
     /// Panics if the values have incompatible shapes
+    #[must_use]
     pub fn couple_infallible(mut self, other: Self, allow_ext: bool) -> Self {
         self.couple_impl(other, allow_ext, &()).unwrap();
         self
@@ -833,6 +836,7 @@ impl<T: ArrayValue> Array<T> {
     ///
     /// # Panics
     /// Panics if the arrays have incompatible shapes
+    #[must_use]
     pub fn couple_infallible(mut self, other: Self, allow_ext: bool) -> Self {
         self.couple_impl(other, allow_ext, &()).unwrap();
         self

src/algorithm/monadic/mod.rs

@@ -1317,6 +1317,7 @@ impl<T: ArrayValue> Array<T> {
 
 impl Value {
     /// `classify` the rows of the value
+    #[must_use]
     pub fn classify(&self) -> Self {
         if self.rank() == 0 {
             return 0.into();
@@ -1344,6 +1345,7 @@ impl Value {
         val_as_arr!(self, |a| a.deduplicate(env))
     }
     /// Mask the `unique` rows of the value
+    #[must_use]
     pub fn unique(&self) -> Self {
         val_as_arr!(self, Array::unique).into()
     }

src/array.rs

@@ -321,6 +321,7 @@ pub struct PersistentMeta {
 
 impl PersistentMeta {
     /// XOR this metadata with another
+    #[must_use]
     pub fn xor(self, other: Self) -> Self {
         Self {
             label: self.label.xor(other.label),
@@ -492,6 +493,7 @@ impl<T: Clone> Array<T> {
     }
     /// Get a row array
     #[track_caller]
+    #[must_use]
     pub fn row(&self, row: usize) -> Self {
         if self.rank() == 0 {
             let mut row = self.clone();
@@ -633,6 +635,7 @@ impl<T: ArrayValue> Array<T> {
     /// - `start` must be <= `end`
     /// - `start` must be < `self.row_count()`
     /// - `end` must be <= `self.row_count()`
+    #[must_use]
     pub fn slice_rows(&self, start: usize, end: usize) -> Self {
         assert!(start <= end);
         assert!(start < self.row_count());

src/compile/mod.rs

@@ -307,6 +307,7 @@ impl Compiler {
         }
     }
     /// Set the compiler's assembly
+    #[must_use]
     pub fn with_assembly(self, asm: Assembly) -> Self {
         Self { asm, ..self }
     }