clippy pedantic

Author: hsaikia

src/analytic.rs

@@ -9,6 +9,7 @@ pub fn polygon_area<T: Copy + num::Integer + std::iter::Sum>(polygon: &[(T, T)])
 }
 
 // Pick's formula - Number of interior vertices of a polygon given its area and boundary points
+#[must_use]
 pub fn polygon_inner_vertices(area: usize, num_boundary_points: usize) -> usize {
     area + 1 - num_boundary_points / 2
 }

src/bin/2015_01/main.rs

@@ -1,8 +1,8 @@
 use aoc::common;
 
 fn part1(input: &str) -> i32 {
-    input.chars().filter(|&c| c == '(').count() as i32
-        - input.chars().filter(|&c| c == ')').count() as i32
+    i32::try_from(input.chars().filter(|&c| c == '(').count()).unwrap()
+        - i32::try_from(input.chars().filter(|&c| c == ')').count()).unwrap()
 }
 
 fn part2(input: &str) -> usize {

src/bin/2015_02/main.rs

@@ -8,7 +8,7 @@ fn part1(input: &str) -> i32 {
             .map(|s| s.parse::<i32>().unwrap())
             .collect::<Vec<_>>();
         let mut areas = [dims[0] * dims[1], dims[1] * dims[2], dims[2] * dims[0]];
-        areas.sort();
+        areas.sort_unstable();
         let wrapping_paper_area = areas[0] + 2 * (areas[0] + areas[1] + areas[2]);
         total_wrapping_paper_area += wrapping_paper_area;
     }
@@ -22,7 +22,7 @@ fn part2(input: &str) -> i32 {
             .split('x')
             .map(|s| s.parse::<i32>().unwrap())
             .collect::<Vec<_>>();
-        dims.sort();
+        dims.sort_unstable();
         let ribbon_length = 2 * (dims[0] + dims[1]) + dims[0] * dims[1] * dims[2];
         total_ribbon_length += ribbon_length;
     }

src/bin/2020_20/main.rs

@@ -13,8 +13,8 @@ enum Order {
     Reverse,
 }
 
-fn border(g: &Grid<char>, dir: &CardinalDirection) -> Vec<char> {
-    match *dir {
+fn border(g: &Grid<char>, dir: CardinalDirection) -> Vec<char> {
+    match dir {
         CardinalDirection::North => g.values[0].clone(),
         CardinalDirection::South => g.values[g.rows - 1].clone(),
         CardinalDirection::West => (0..g.rows).map(|r| g.values[r][0]).collect_vec(),
@@ -26,8 +26,8 @@ fn matching_borders(
     g1: (&Grid<char>, &CardinalDirection),
     g2: (&Grid<char>, &CardinalDirection),
 ) -> Option<Order> {
-    let val1 = border(g1.0, g1.1);
-    let val2 = border(g2.0, g2.1);
+    let val1 = border(g1.0, *g1.1);
+    let val2 = border(g2.0, *g2.1);
 
     if val1 == val2 {
         return Some(Order::Straight);
@@ -43,7 +43,7 @@ fn matching_borders(
 fn part1(input: &str) -> usize {
     let grid_strs = io::line_batches(input);
     let n = grid_strs.len();
-    println!("Cells {}", n);
+    println!("Cells {n}");
     let mut grid_with_ids: Vec<(Grid<char>, usize)> = Vec::new();
 
     for g in grid_strs {
@@ -86,9 +86,9 @@ fn part1(input: &str) -> usize {
         .filter(|(_, v)| v.len() == 2)
         .map(|(k, _)| *k)
         .product::<usize>();
-    for (key, val) in matches.iter() {
+    for (key, val) in &matches {
         if val.len() == 2 {
-            println!("{:?} => {:?}", key, val);
+            println!("{key:?} => {val:?}");
         }
     }
 

src/bin/2022_04/main.rs

@@ -5,14 +5,8 @@ fn part1(input_lines: &str) -> usize {
 
     for line in input_lines.split('\n') {
         let ranges: Vec<_> = line.split(',').collect();
-        let idx1: Vec<_> = ranges[0]
-            .split('-')
-            .flat_map(|s| s.parse::<usize>())
-            .collect();
-        let idx2: Vec<_> = ranges[1]
-            .split('-')
-            .flat_map(|s| s.parse::<usize>())
-            .collect();
+        let idx1: Vec<_> = ranges[0].split('-').flat_map(str::parse::<usize>).collect();
+        let idx2: Vec<_> = ranges[1].split('-').flat_map(str::parse::<usize>).collect();
 
         if (idx2[0] >= idx1[0] && idx2[1] <= idx1[1]) || (idx1[0] >= idx2[0] && idx1[1] <= idx2[1])
         {
@@ -28,14 +22,8 @@ fn part2(input_lines: &str) -> usize {
 
     for line in input_lines.split('\n') {
         let ranges: Vec<_> = line.split(',').collect();
-        let idx1: Vec<_> = ranges[0]
-            .split('-')
-            .flat_map(|s| s.parse::<usize>())
-            .collect();
-        let idx2: Vec<_> = ranges[1]
-            .split('-')
-            .flat_map(|s| s.parse::<usize>())
-            .collect();
+        let idx1: Vec<_> = ranges[0].split('-').flat_map(str::parse::<usize>).collect();
+        let idx2: Vec<_> = ranges[1].split('-').flat_map(str::parse::<usize>).collect();
 
         let idx_l = idx1[0].max(idx2[0]);
         let idx_r = idx1[1].min(idx2[1]);

src/bin/2022_05/main.rs

@@ -10,7 +10,7 @@ fn part1(stacks: &[Vec<char>], instructions: &Vec<Vec<usize>>) -> String {
         }
     }
 
-    stacks.iter().flat_map(|v| v.last()).collect::<String>()
+    stacks.iter().filter_map(|v| v.last()).collect::<String>()
 }
 
 fn part2(stacks: &[Vec<char>], instructions: &Vec<Vec<usize>>) -> String {
@@ -24,7 +24,7 @@ fn part2(stacks: &[Vec<char>], instructions: &Vec<Vec<usize>>) -> String {
         stacks[ins[1] - 1].truncate(l - ins[0]);
     }
 
-    stacks.iter().flat_map(|v| v.last()).collect::<String>()
+    stacks.iter().filter_map(|v| v.last()).collect::<String>()
 }
 
 fn process_and_solve<const PART1: bool>(input: &str) -> String {
@@ -61,7 +61,7 @@ fn process_and_solve<const PART1: bool>(input: &str) -> String {
         } else {
             instructions.push(
                 line.split(' ')
-                    .flat_map(|s| s.parse::<usize>())
+                    .flat_map(str::parse::<usize>)
                     .collect::<Vec<usize>>(),
             );
         }

src/bin/2022_07/main.rs

@@ -2,17 +2,16 @@ use aoc::common;
 use std::collections::HashMap;
 
 fn process_and_solve<const PART1: bool>(input_lines: &str) -> usize {
+    const DIR_SEP: &str = "/";
     let mut curr_dir_path: Vec<String> = Vec::new();
     let mut curr_total_filesizes: usize = 0;
     let mut dir_size_map: HashMap<String, usize> = HashMap::new();
     let mut reading = false;
 
-    const DIR_SEP: &str = "/";
-
     for line in input_lines.split('\n') {
         let tokens = line
             .split(' ')
-            .map(|s| s.to_string())
+            .map(std::string::ToString::to_string)
             .collect::<Vec<String>>();
 
         if reading && tokens[0] != "$" && tokens[0] != "dir" {
@@ -64,7 +63,7 @@ fn process_and_solve<const PART1: bool>(input_lines: &str) -> usize {
 fn part1(dir_size_map: &HashMap<String, usize>) -> usize {
     let mut sum = 0;
     for v in dir_size_map.values() {
-        if *v <= 100000 {
+        if *v <= 100_000 {
             sum += *v;
         }
     }
@@ -73,8 +72,8 @@ fn part1(dir_size_map: &HashMap<String, usize>) -> usize {
 }
 
 fn part2(dir_size_map: &HashMap<String, usize>) -> usize {
-    const TOTAL_DISK_SPACE: usize = 70000000;
-    const UNUSED_SPACE_REQUIRED: usize = 30000000;
+    const TOTAL_DISK_SPACE: usize = 70_000_000;
+    const UNUSED_SPACE_REQUIRED: usize = 30_000_000;
 
     let unused_space = TOTAL_DISK_SPACE - dir_size_map.get("/").unwrap();
     let minimimum_space_to_free = UNUSED_SPACE_REQUIRED - unused_space;

src/bin/2022_08/main.rs

@@ -1,6 +1,7 @@
 use aoc::{common, grid::Grid};
 use itertools::iproduct;
 
+#[allow(clippy::cast_possible_wrap)]
 fn part1(grid: &Grid<u32>) -> usize {
     // Check visibility for each internal tree
     let mut visible = Grid::<bool>::new(grid.rows, grid.cols, false);
@@ -84,7 +85,7 @@ fn part2(grid: &Grid<u32>) -> i32 {
 fn get_grid_and_solve<const PART1: bool>(input: &str) -> i32 {
     let grid = Grid::from_str(input, |c| c.to_digit(10).unwrap());
     if PART1 {
-        return part1(&grid) as i32;
+        return i32::try_from(part1(&grid)).unwrap();
     }
     part2(&grid)
 }

src/bin/2022_09/main.rs

@@ -1,6 +1,7 @@
 use aoc::common;
 use itertools::Itertools;
 
+#[allow(clippy::similar_names)]
 fn follow_knot(head_new: (i32, i32), tail_old: (i32, i32)) -> (i32, i32) {
     let mut dx = head_new.0 - tail_old.0;
     let mut dy = head_new.1 - tail_old.1;

src/bin/2022_10/main.rs

@@ -17,25 +17,27 @@ fn register_history(input_lines: &str) -> Vec<i32> {
     register
 }
 
+#[allow(clippy::cast_possible_truncation)]
+#[allow(clippy::cast_possible_wrap)]
 fn part1(input_lines: &str) -> i32 {
+    const CYCLES: [usize; 6] = [20, 60, 100, 140, 180, 220];
     let mut ans = 0;
     let register = register_history(input_lines);
 
-    const CYCLES: [usize; 6] = [20, 60, 100, 140, 180, 220];
-
     for cycle in CYCLES {
         ans += cycle as i32 * register[cycle - 1];
     }
 
     ans
 }
 
+#[allow(clippy::cast_possible_truncation)]
+#[allow(clippy::cast_possible_wrap)]
 fn part2(input_lines: &str) -> common::GridDisplay {
-    let mut ans = common::GridDisplay { rows: Vec::new() };
-    let register = register_history(input_lines);
-
     const W: usize = 40;
     const H: usize = 6;
+    let mut ans = common::GridDisplay { rows: Vec::new() };
+    let register = register_history(input_lines);
 
     for row in 0..H {
         let mut crt_row = String::new();