clippy

cli/src/repl.rs

@@ -191,7 +191,7 @@ pub fn main() -> io::Result<()> {
     Ok(())
 }
 
-fn report_parse_error<'a>(fail: Bag<'a>) {
+fn report_parse_error(fail: Bag<'_>) {
     println!("TODO Gracefully report parse error in repl: {:?}", fail);
 }
 

compiler/load/src/file.rs

@@ -2198,7 +2198,7 @@ fn load_pkg_config<'a>(
                     Ok(Msg::Many(vec![effects_module_msg, pkg_config_module_msg]))
                 }
                 Err((_, fail, _)) => Err(LoadingProblem::ParsingFailed(
-                    fail.to_parse_problem(filename, bytes),
+                    fail.into_parse_problem(filename, bytes),
                 )),
             }
         }
@@ -2445,7 +2445,7 @@ fn parse_header<'a>(
             module_timing,
         ),
         Err((_, fail, _)) => Err(LoadingProblem::ParsingFailed(
-            fail.to_parse_problem(filename, src_bytes),
+            fail.into_parse_problem(filename, src_bytes),
         )),
     }
 }
@@ -3459,7 +3459,7 @@ fn parse<'a>(arena: &'a Bump, header: ModuleHeader<'a>) -> Result<Msg<'a>, Loadi
         Ok((_, success, _state)) => success,
         Err((_, fail, _)) => {
             return Err(LoadingProblem::ParsingFailed(
-                fail.to_parse_problem(header.module_path, header.src),
+                fail.into_parse_problem(header.module_path, header.src),
             ));
         }
     };

compiler/parse/src/expr.rs

@@ -580,7 +580,7 @@ type Body<'a> = (Located<Pattern<'a>>, Located<Expr<'a>>);
 
 fn body<'a>(min_indent: u16) -> impl Parser<'a, Body<'a>> {
     let indented_more = min_indent + 1;
-    let result = and!(
+    and!(
         // this backtrackable is required for the case
         //
         // i = 64
@@ -601,8 +601,7 @@ fn body<'a>(min_indent: u16) -> impl Parser<'a, Body<'a>> {
                 .parse(a, s)
             }
         )
-    );
-    result
+    )
 }
 
 fn body_at_indent<'a>(indent_level: u16) -> impl Parser<'a, Body<'a>> {

compiler/parse/src/module.rs

@@ -297,14 +297,8 @@ pub fn platform_header<'a>() -> impl Parser<'a, PlatformHeader<'a>> {
 
 #[inline(always)]
 pub fn module_defs<'a>() -> impl Parser<'a, Vec<'a, Located<Def<'a>>>> {
-    move |a: &'a Bump, s: State<'a>| {
-        // this parses just the defs
-        let defs = zero_or_more!(space0_around(loc(def(0)), 0));
-
-        let result = skip_second!(defs, end_of_file()).parse(a, s);
-
-        result
-    }
+    // force that we pare until the end of the input
+    skip_second!(zero_or_more!(space0_around(loc(def(0)), 0)), end_of_file())
 }
 
 struct ProvidesTo<'a> {

compiler/parse/src/parser.rs

@@ -75,7 +75,7 @@ impl<'a> State<'a> {
 
     /// Returns whether the parser has reached the end of the input
     pub fn has_reached_end(&self) -> bool {
-        self.bytes.len() == 0
+        self.bytes.is_empty()
     }
 
     /// Increments the line, then resets column, indent_col, and is_indenting.
@@ -274,7 +274,7 @@ pub enum ContextStack<'a> {
 }
 
 impl<'a> ContextStack<'a> {
-    fn to_vec(self) -> std::vec::Vec<ContextItem> {
+    fn into_vec(self) -> std::vec::Vec<ContextItem> {
         let mut result = std::vec::Vec::new();
         let mut next = &self;
 
@@ -338,15 +338,15 @@ impl<'a> Bag<'a> {
         self.0.pop()
     }
 
-    pub fn to_parse_problem<'b>(
+    pub fn into_parse_problem(
         mut self,
         filename: std::path::PathBuf,
-        bytes: &'b [u8],
-    ) -> ParseProblem<'b> {
+        bytes: &[u8],
+    ) -> ParseProblem<'_> {
         match self.pop() {
             None => unreachable!("there is a parse error, but no problem"),
             Some(dead_end) => {
-                let context_stack = dead_end.context_stack.to_vec();
+                let context_stack = dead_end.context_stack.into_vec();
 
                 ParseProblem {
                     line: dead_end.line,
@@ -792,8 +792,8 @@ where
                 }
             }
             Err((element_progress, fail, new_state)) => match element_progress {
-                MadeProgress => return Err((MadeProgress, fail, new_state)),
-                NoProgress => return Ok((NoProgress, Vec::new_in(arena), new_state)),
+                MadeProgress => Err((MadeProgress, fail, new_state)),
+                NoProgress => Ok((NoProgress, Vec::new_in(arena), new_state)),
             },
         }
     }
@@ -849,8 +849,8 @@ where
                 }
             }
             Err((element_progress, fail, new_state)) => match element_progress {
-                MadeProgress => return Err((MadeProgress, fail, new_state)),
-                NoProgress => return Ok((NoProgress, Vec::new_in(arena), new_state)),
+                MadeProgress => Err((MadeProgress, fail, new_state)),
+                NoProgress => Ok((NoProgress, Vec::new_in(arena), new_state)),
             },
         }
     }

compiler/reporting/tests/test_reporting.rs

@@ -129,7 +129,7 @@ mod test_reporting {
 
                 let alloc = RocDocAllocator::new(&src_lines, home, &interns);
 
-                let problem = fail.to_parse_problem(filename.clone(), src.as_bytes());
+                let problem = fail.into_parse_problem(filename.clone(), src.as_bytes());
                 let doc = parse_problem(&alloc, filename, 0, problem);
 
                 callback(doc.pretty(&alloc).append(alloc.line()), buf)