Bump Rust version to 1.83

Author: maneatingape

Cargo.toml

@@ -2,7 +2,7 @@
 name = "aoc"
 version = "2024.12.25"
 edition = "2021"
-rust-version = "1.82"
+rust-version = "1.83"
 
 [features]
 frivolity = []
@@ -194,6 +194,7 @@ needless_raw_strings = "warn"
 no_effect_underscore_binding = "warn"
 no_mangle_with_rust_abi = "warn"
 non_ascii_literal = "allow"
+non_zero_suggestions = "warn"
 option_as_ref_cloned = "warn"
 option_option = "warn"
 panic = "allow"
@@ -219,7 +220,7 @@ redundant_else = "warn"
 redundant_type_annotations = "warn"
 ref_as_ptr = "warn"
 ref_binding_to_reference = "warn"
-ref_option_ref = "warn"
+ref_option = "warn"
 ref_patterns = "warn"
 renamed_function_params = "warn"
 rest_pat_in_fully_bound_structs = "warn"
@@ -279,6 +280,7 @@ unseparated_literal_suffix = "warn"
 unused_async = "warn"
 unused_result_ok = "warn"
 unused_self = "warn"
+unused_trait_names = "warn"
 unwrap_in_result = "allow"
 unwrap_used = "allow"
 use_debug = "warn"

src/util/hash.rs

@@ -6,7 +6,7 @@
 //! resistant but slower hashing algorithm. [`FxHasher`] is much faster (between 2x to 5x from my testing).
 use std::collections::{HashMap, HashSet};
 use std::hash::{BuildHasher, Hash, Hasher};
-use std::ops::BitXor;
+use std::ops::BitXor as _;
 
 /// Type alias for [`HashSet`] using [`FxHasher`].
 pub type FastSet<T> = HashSet<T, BuildFxHasher>;

src/year2017/day10.rs

@@ -7,7 +7,7 @@
 //! [`rotate_left`]: slice::rotate_left
 //! [`reverse`]: slice::reverse
 use crate::util::parse::*;
-use std::fmt::Write;
+use std::fmt::Write as _;
 
 pub fn parse(input: &str) -> &str {
     input

src/year2019/day13.rs

@@ -92,7 +92,7 @@ pub fn part2(input: &[i64]) -> i64 {
 #[cfg(feature = "frivolity")]
 fn draw(tiles: &[i64], score: i64, blocks: i64) {
     use crate::util::ansi::*;
-    use std::fmt::Write;
+    use std::fmt::Write as _;
     use std::thread::sleep;
     use std::time::Duration;
 

src/year2019/day17.rs

@@ -18,7 +18,7 @@ use super::intcode::*;
 use crate::util::hash::*;
 use crate::util::parse::*;
 use crate::util::point::*;
-use std::fmt::Write;
+use std::fmt::Write as _;
 use std::ops::ControlFlow;
 
 pub struct Input {

src/year2019/day25.rs

@@ -19,7 +19,7 @@
 use super::intcode::*;
 use crate::util::hash::*;
 use crate::util::parse::*;
-use std::fmt::Write;
+use std::fmt::Write as _;
 
 pub fn parse(input: &str) -> Vec<i64> {
     input.iter_signed().collect()

src/year2024/day09.rs

@@ -29,39 +29,40 @@ pub fn parse(input: &str) -> Vec<usize> {
 /// Block by block checksum comparison that doesn't allocate any memory.
 pub fn part1(disk: &[usize]) -> usize {
     // Start at the first free block and the last file.
-    let mut free = 0;
-    let mut file = disk.len() + disk.len() % 2;
+    let mut left = 0;
+    let mut right = disk.len() + disk.len() % 2;
 
-    let mut available = 0;
+    let mut available;
     let mut needed = 0;
 
     let mut block = 0;
     let mut checksum = 0;
 
-    while free < file {
-        // Take as much space as possible from the current free block range.
-        let size = needed.min(available);
-        (checksum, block) = update(checksum, block, file, size);
-        available -= size;
-        needed -= size;
-
-        // One or both of "available" and "free" could be zero.
-        if needed == 0 {
-            file -= 2;
-            needed = disk[file];
-        }
-
+    while left < right {
         // When moving to the next free block, add the checksum for the file we're skipping over.
-        if available == 0 {
-            let size = disk[free];
-            (checksum, block) = update(checksum, block, free, size);
-            available = disk[free + 1];
-            free += 2;
+        (checksum, block) = update(checksum, block, left, disk[left]);
+        available = disk[left + 1];
+        left += 2;
+
+        while available > 0 {
+            if needed == 0 {
+                if right == left {
+                    break;
+                }
+                right -= 2;
+                needed = disk[right];
+            }
+
+            // Take as much space as possible from the current free block range.
+            let size = needed.min(available);
+            (checksum, block) = update(checksum, block, right, size);
+            available -= size;
+            needed -= size;
         }
     }
 
     // Account for any remaining file blocks left over.
-    (checksum, _) = update(checksum, block, file, needed);
+    (checksum, _) = update(checksum, block, right, needed);
     checksum
 }
 
@@ -92,8 +93,9 @@ pub fn part2(disk: &[usize]) -> usize {
         let mut next_block = block;
         let mut next_index = usize::MAX;
 
-        for (i, heap) in free.iter().enumerate().skip(size) {
-            if let Some((&first, ())) = heap.peek() {
+        #[allow(clippy::needless_range_loop)]
+        for i in size..free.len() {
+            if let Some((&first, ())) = free[i].peek() {
                 if first < next_block {
                     next_block = first;
                     next_index = i;