Rustc lints

Author: maneatingape

Diff for: src/lib.rs

@@ -5,6 +5,36 @@
 // Configure rustdoc
 #![doc(html_logo_url = "https://maneatingape.github.io/advent-of-code-rust/logo.png")]
 #![allow(rustdoc::private_intra_doc_links)]
+// Stricter Rustc lints
+#![warn(
+    absolute_paths_not_starting_with_crate,
+    elided_lifetimes_in_paths,
+    explicit_outlives_requirements,
+    ffi_unwind_calls,
+    //invalid_reference_casting, // Not supported by GitHub actions yet
+    keyword_idents,
+    let_underscore_drop,
+    macro_use_extern_crate,
+    meta_variable_misuse,
+    missing_abi,
+    non_ascii_idents,
+    noop_method_call,
+    pointer_structural_match,
+    single_use_lifetimes,
+    trivial_casts,
+    trivial_numeric_casts,
+    unreachable_pub,
+    unsafe_code,
+    unsafe_op_in_unsafe_fn,
+    unused_crate_dependencies,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_lifetimes,
+    unused_macro_rules,
+    unused_qualifications,
+    unused_tuple_struct_fields,
+    variant_size_differences
+)]
 // Clippy Pedantic lints excluding some noisy rules.
 #![warn(clippy::pedantic)]
 #![allow(clippy::similar_names)]

Diff for: src/util/parse.rs

@@ -108,7 +108,7 @@ impl<T: Signed> Iterator for ParseSigned<'_, T> {
     }
 }
 
-fn try_unsigned<T: Unsigned>(bytes: &mut Bytes) -> Option<T> {
+fn try_unsigned<T: Unsigned>(bytes: &mut Bytes<'_>) -> Option<T> {
     let mut n = loop {
         let byte = bytes.next()?;
         let digit = byte.to_decimal();
@@ -130,7 +130,7 @@ fn try_unsigned<T: Unsigned>(bytes: &mut Bytes) -> Option<T> {
     }
 }
 
-fn try_signed<T: Signed>(bytes: &mut Bytes) -> Option<T> {
+fn try_signed<T: Signed>(bytes: &mut Bytes<'_>) -> Option<T> {
     let (mut n, negative) = loop {
         let byte = bytes.next()?;
         let digit = byte.to_decimal();

Diff for: src/year2015/day04.rs

@@ -57,7 +57,7 @@ pub fn parse(input: &str) -> Shared {
 
     // Wait for threads to finish
     for handle in handles {
-        let _ = handle.join();
+        let _unused = handle.join();
     }
 
     shared

Diff for: src/year2020/day02.rs

@@ -20,7 +20,7 @@ pub struct Rule<'a> {
 }
 
 impl Rule<'_> {
-    fn from([a, b, c, d]: [&str; 4]) -> Rule {
+    fn from([a, b, c, d]: [&str; 4]) -> Rule<'_> {
         let start = a.unsigned();
         let end = b.unsigned();
         let letter = c.as_bytes()[0];
@@ -29,7 +29,7 @@ impl Rule<'_> {
     }
 }
 
-pub fn parse(input: &str) -> Vec<Rule> {
+pub fn parse(input: &str) -> Vec<Rule<'_>> {
     input
         .split(['-', ':', ' ', '\n'])
         .filter(|s| !s.is_empty())
@@ -38,7 +38,7 @@ pub fn parse(input: &str) -> Vec<Rule> {
         .collect()
 }
 
-pub fn part1(input: &[Rule]) -> usize {
+pub fn part1(input: &[Rule<'_>]) -> usize {
     input
         .iter()
         .filter(|rule| {
@@ -48,7 +48,7 @@ pub fn part1(input: &[Rule]) -> usize {
         .count()
 }
 
-pub fn part2(input: &[Rule]) -> usize {
+pub fn part2(input: &[Rule<'_>]) -> usize {
     input
         .iter()
         .filter(|rule| {

Diff for: src/year2020/day04.rs

@@ -9,23 +9,23 @@ use std::ops::RangeInclusive;
 
 type Passport<'a> = Vec<[&'a str; 2]>;
 
-pub fn parse(input: &str) -> Vec<Passport> {
+pub fn parse(input: &str) -> Vec<Passport<'_>> {
     input.split("\n\n").map(parse_block).collect()
 }
 
-pub fn part1(input: &[Passport]) -> usize {
+pub fn part1(input: &[Passport<'_>]) -> usize {
     input.iter().filter(|passport| passport.len() == 7).count()
 }
 
-pub fn part2(input: &[Passport]) -> usize {
+pub fn part2(input: &[Passport<'_>]) -> usize {
     input
         .iter()
         .filter(|passport| passport.len() == 7)
         .filter(|passport| passport.iter().all(validate_field))
         .count()
 }
 
-fn parse_block(block: &str) -> Passport {
+fn parse_block(block: &str) -> Passport<'_> {
     let mut fields = Vec::with_capacity(7);
 
     for pair @ [key, _] in block.split([':', ' ', '\n']).chunk::<2>() {

Diff for: src/year2020/day17.rs

@@ -18,7 +18,7 @@ use crate::util::point::*;
 /// axis per round (one positive and one negative). Adding padding at the edges to avoid boundary
 /// checks gives a maximum width of 8 + 2 * (6 + 1) = 22 for the x and y dimensions and
 /// 1 + 2 * (6 + 1) = 15 for the z and w dimensions.
-mod size {
+pub mod size {
     pub const X: i32 = 22;
     pub const Y: i32 = 22;
     pub const Z: i32 = 15;
@@ -27,7 +27,7 @@ mod size {
 
 /// Pack a four dimensional array into a one dimensional vec to avoid the speed penalty of
 /// following multiple pointers and increase memory locality for caching.
-mod stride {
+pub mod stride {
     use super::size;
     pub const X: i32 = 1;
     pub const Y: i32 = size::X * X;

Diff for: src/year2020/day18.rs

@@ -18,7 +18,7 @@ pub fn parse(input: &str) -> Vec<&str> {
 }
 
 pub fn part1(input: &[&str]) -> u64 {
-    fn helper(bytes: &mut Bytes) -> u64 {
+    fn helper(bytes: &mut Bytes<'_>) -> u64 {
         let mut total = value(bytes, helper);
 
         while let Some(operation) = next(bytes) {
@@ -37,7 +37,7 @@ pub fn part1(input: &[&str]) -> u64 {
 }
 
 pub fn part2(input: &[&str]) -> u64 {
-    fn helper(bytes: &mut Bytes) -> u64 {
+    fn helper(bytes: &mut Bytes<'_>) -> u64 {
         let mut total = value(bytes, helper);
 
         while let Some(operation) = next(bytes) {
@@ -60,7 +60,7 @@ pub fn part2(input: &[&str]) -> u64 {
 /// Convenience wrapper around [`Bytes`] iterator. Encountering a `)` is also considered end of
 /// sequence. The expressions are consistently formatted so encountering a space just means
 /// skip and return the next character that will always be present.
-fn next(bytes: &mut Bytes) -> Option<u8> {
+fn next(bytes: &mut Bytes<'_>) -> Option<u8> {
     match bytes.next() {
         None | Some(b')') => None,
         Some(b' ') => bytes.next(),
@@ -70,7 +70,7 @@ fn next(bytes: &mut Bytes) -> Option<u8> {
 
 /// Convenience wrapper to return the value of either the next raw digit literal or a
 /// sub-expression nested in parentheses.
-fn value(bytes: &mut Bytes, helper: impl Fn(&mut Bytes) -> u64) -> u64 {
+fn value(bytes: &mut Bytes<'_>, helper: impl Fn(&mut Bytes<'_>) -> u64) -> u64 {
     match next(bytes).unwrap() {
         b'(' => helper(bytes),
         b => b.to_decimal() as u64,

Diff for: src/year2020/day19.rs

@@ -65,7 +65,7 @@ pub enum Rule {
 
 type Input<'a> = (Vec<Rule>, Vec<&'a [u8]>);
 
-pub fn parse(input: &str) -> Input {
+pub fn parse(input: &str) -> Input<'_> {
     let (prefix, suffix) = input.split_once("\n\n").unwrap();
     let mut tokens = Vec::new();
     let mut rules = vec![Letter(0); 640]; // 640 rules ought to be enough for anybody.
@@ -88,12 +88,12 @@ pub fn parse(input: &str) -> Input {
     (rules, messages)
 }
 
-pub fn part1(input: &Input) -> usize {
+pub fn part1(input: &Input<'_>) -> usize {
     let (rules, messages) = input;
     messages.iter().filter(|message| check(rules, 0, message, 0) == Some(message.len())).count()
 }
 
-pub fn part2(input: &Input) -> usize {
+pub fn part2(input: &Input<'_>) -> usize {
     let (rules, messages) = input;
     let predicate = |message: &&&[u8]| {
         let mut index = 0;

Diff for: src/year2020/day21.rs

@@ -57,7 +57,7 @@ pub struct Ingredient {
     candidates: usize,
 }
 
-pub fn parse(input: &str) -> Input {
+pub fn parse(input: &str) -> Input<'_> {
     let mut ingredients: FastMap<&str, Ingredient> = FastMap::new();
     let mut allergens = FastMap::new();
     let mut allergens_per_food = Vec::new();
@@ -97,11 +97,11 @@ pub fn parse(input: &str) -> Input {
     Input { ingredients, allergens }
 }
 
-pub fn part1(input: &Input) -> u32 {
+pub fn part1(input: &Input<'_>) -> u32 {
     input.ingredients.values().filter(|i| i.candidates == 0).map(|i| i.food.count_ones()).sum()
 }
 
-pub fn part2(input: &Input) -> String {
+pub fn part2(input: &Input<'_>) -> String {
     let mut ingredients = input.ingredients.clone();
     ingredients.retain(|_, v| v.candidates != 0);
 

Diff for: src/year2021/day03.rs

@@ -12,12 +12,12 @@ pub struct Input<'a> {
     numbers: Vec<&'a [u8]>,
 }
 
-pub fn parse(input: &str) -> Input {
+pub fn parse(input: &str) -> Input<'_> {
     let numbers: Vec<_> = input.lines().map(str::as_bytes).collect();
     Input { width: numbers[0].len(), numbers }
 }
 
-pub fn part1(input: &Input) -> u32 {
+pub fn part1(input: &Input<'_>) -> u32 {
     let mut gamma = 0;
     let mut epsilon = 0;
 
@@ -35,7 +35,7 @@ pub fn part1(input: &Input) -> u32 {
     gamma * epsilon
 }
 
-pub fn part2(input: &Input) -> u32 {
+pub fn part2(input: &Input<'_>) -> u32 {
     let gamma = rating(input, |a, b| a >= b);
     let epsilon = rating(input, |a, b| a < b);
     gamma * epsilon
@@ -50,7 +50,7 @@ fn fold(numbers: &[u8], width: usize) -> u32 {
     numbers.iter().take(width).fold(0, |acc, &n| (acc << 1) | (n & 1) as u32)
 }
 
-fn rating(input: &Input, cmp: impl Fn(usize, usize) -> bool) -> u32 {
+fn rating(input: &Input<'_>, cmp: impl Fn(usize, usize) -> bool) -> u32 {
     let mut numbers = input.numbers.clone();
 
     for i in 0..input.width {

Diff for: src/year2021/day16.rs

@@ -22,7 +22,7 @@ struct BitStream<'a> {
 }
 
 impl BitStream<'_> {
-    fn from(s: &str) -> BitStream {
+    fn from(s: &str) -> BitStream<'_> {
         BitStream { available: 0, bits: 0, read: 0, iter: s.bytes() }
     }
 
@@ -56,7 +56,7 @@ pub enum Packet {
 }
 
 impl Packet {
-    fn from(bit_stream: &mut BitStream) -> Packet {
+    fn from(bit_stream: &mut BitStream<'_>) -> Packet {
         let version = bit_stream.next(3);
         let type_id = bit_stream.next(3);
 

Diff for: src/year2022/day13.rs

@@ -25,7 +25,7 @@ struct Packet<'a> {
 }
 
 impl Packet<'_> {
-    fn new(str: &str) -> Packet {
+    fn new(str: &str) -> Packet<'_> {
         Packet { slice: str.as_bytes(), index: 0, extra: Vec::new() }
     }
 }

Diff for: src/year2022/day16.rs

@@ -25,7 +25,7 @@ pub struct Valve<'a> {
 }
 
 impl Valve<'_> {
-    fn parse(line: &str) -> Valve {
+    fn parse(line: &str) -> Valve<'_> {
         let mut tokens: Vec<_> = line
             .split(|c: char| !c.is_ascii_uppercase() && !c.is_ascii_digit())
             .filter(|s| !s.is_empty())
@@ -36,7 +36,7 @@ impl Valve<'_> {
         Valve { name, flow, edges: tokens }
     }
 
-    fn cmp(&self, other: &Valve) -> Ordering {
+    fn cmp(&self, other: &Valve<'_>) -> Ordering {
         let first = other.flow.cmp(&self.flow);
         if first == Ordering::Equal {
             self.name.cmp(other.name)

Diff for: src/year2022/day17.rs

@@ -27,7 +27,7 @@ struct State<'a> {
 }
 
 impl State<'_> {
-    fn new(input: &[u8]) -> State {
+    fn new(input: &[u8]) -> State<'_> {
         let mut state = State {
             rocks: ROCKS.iter().copied().cycle(),
             jets: input.iter().copied().cycle(),
@@ -39,7 +39,7 @@ impl State<'_> {
     }
 }
 
-impl<'a> Iterator for State<'a> {
+impl Iterator for State<'_> {
     type Item = usize;
 
     fn next(&mut self) -> Option<Self::Item> {