fix clippy

Author: stringhandler

src/ast.rs

@@ -797,15 +797,12 @@ impl Program {
         let mut main_seen = false;
         for (item, mut warnings) in items {
             all_warnings.append(&mut warnings);
-            match item {
-                Item::Function(Function::Main(expr)) => {
-                    if main_seen {
-                        return Err(Error::FunctionRedefined(FunctionName::main())).with_span(from);
-                    }
-                    main_seen = true;
-                    main_expr = Some(expr);
+            if let Item::Function(Function::Main(expr)) = item {
+                if main_seen {
+                    return Err(Error::FunctionRedefined(FunctionName::main())).with_span(from);
                 }
-                _ => {}
+                main_seen = true;
+                main_expr = Some(expr);
             }
         }
         let main = main_expr.ok_or(Error::MainRequired).with_span(from)?;
@@ -1506,9 +1503,8 @@ impl AbstractSyntaxTree for CallName {
                 if function.params().len() != 2 || function.params()[1].ty() != function.body().ty()
                 {
                     return Err(Error::FunctionNotFoldable(name.clone())).with_span(from);
-                } else {
-                    Self::ArrayFold(function, *size)
                 }
+                Self::ArrayFold(function, *size)
             }
             parse::CallName::Fold(name, bound) => {
                 let function = scope
@@ -1521,9 +1517,8 @@ impl AbstractSyntaxTree for CallName {
                 if function.params().len() != 2 || function.params()[1].ty() != function.body().ty()
                 {
                     return Err(Error::FunctionNotFoldable(name.clone())).with_span(from);
-                } else {
-                    Self::Fold(function, *bound)
                 }
+                Self::Fold(function, *bound)
             }
             parse::CallName::ForWhile(name) => {
                 let function = scope

src/error.rs

@@ -149,7 +149,7 @@ impl<T> WithFilePath<T> for Result<T, RichError> {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct RichError {
     /// The error that occurred.
-    error: Error,
+    error: Box<Error>,
     /// Area that the error spans inside the file.
     span: Span,
     /// File contents in which the error occurred.
@@ -164,7 +164,7 @@ impl RichError {
     /// Create a new error with context.
     pub fn new(error: Error, span: Span) -> RichError {
         RichError {
-            error,
+            error: Box::new(error),
             span,
             file: None,
             file_path: None,
@@ -193,7 +193,7 @@ impl RichError {
     /// a problem on the parsing side.
     pub fn parsing_error(reason: &str) -> Self {
         Self {
-            error: Error::CannotParse(reason.to_string()),
+            error: Box::new(Error::CannotParse(reason.to_string())),
             span: Span::new(0, 0),
             file: None,
             file_path: None,
@@ -315,7 +315,7 @@ impl std::error::Error for RichError {}
 
 impl From<RichError> for Error {
     fn from(error: RichError) -> Self {
-        error.error
+        *error.error
     }
 }
 
@@ -331,7 +331,7 @@ where
     I: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
 {
     fn merge(self, other: Self) -> Self {
-        match (&self.error, &other.error) {
+        match (self.error.as_ref(), other.error.as_ref()) {
             (Error::Grammar(_), Error::Grammar(_)) => other,
             (Error::Grammar(_), _) => other,
             (_, Error::Grammar(_)) => self,
@@ -367,11 +367,11 @@ where
         let found_string = found.map(|t| t.to_string());
 
         Self {
-            error: Error::Syntax {
+            error: Box::new(Error::Syntax {
                 expected: expected_tokens,
                 label: None,
                 found: found_string,
-            },
+            }),
             span,
             file: None,
             file_path: None,
@@ -395,11 +395,11 @@ where
         let found_string = found.map(|t| t.to_string());
 
         Self {
-            error: Error::Syntax {
+            error: Box::new(Error::Syntax {
                 expected: expected_strings,
                 label: None,
                 found: found_string,
-            },
+            }),
             span,
             file: None,
             file_path: None,
@@ -409,7 +409,7 @@ where
     fn label_with(&mut self, label: &'tokens str) {
         if let Error::Syntax {
             label: ref mut l, ..
-        } = &mut self.error
+        } = self.error.as_mut()
         {
             *l = Some(label.to_string());
         }

src/lib.rs

@@ -894,8 +894,8 @@ fn main() {
             let names = warning_names(prog);
             let unused: Vec<&str> = names
                 .iter()
-                .filter_map(|w| match w {
-                    WarningName::UnusedVariable(id) => Some(id.as_inner()),
+                .map(|w| match w {
+                    WarningName::UnusedVariable(id) => id.as_inner(),
                 })
                 .collect();
             assert_eq!(

src/main.rs

@@ -135,15 +135,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let deny_warnings = matches.get_flag("deny_warnings");
 
-    fn parse_warn_category(s: &str) -> Result<WarnCategory, String> {
-        match s {
-            "unused-variable" => Ok(WarnCategory::UnusedVariable),
-            other => Err(format!(
-                "unknown warning category `{other}`; valid categories: unused-variable"
-            )),
-        }
-    }
-
     let deny_categories: Vec<WarnCategory> = matches
         .get_many::<String>("deny_warning")
         .unwrap_or_default()
@@ -178,7 +169,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let template = deny_categories
         .iter()
-        .fold(Ok(template), |t, &cat| t.and_then(|t| t.deny_warning(cat)))
+        .try_fold(template, |t, &cat| t.deny_warning(cat))
         .unwrap_or_else(|e| {
             eprintln!("{e}");
             std::process::exit(1);
@@ -268,3 +259,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+fn parse_warn_category(s: &str) -> Result<WarnCategory, String> {
+    match s {
+        "unused-variable" => Ok(WarnCategory::UnusedVariable),
+        other => Err(format!(
+            "unknown warning category `{other}`; valid categories: unused-variable"
+        )),
+    }
+}