migrate to rust edition 2024

Author: bircni

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "arnis"
 version = "2.4.0"
-edition = "2021"
+edition = "2024"
 description = "Arnis - Generate real life cities in Minecraft"
 homepage = "https://github.com/louis-e/arnis"
 repository = "https://github.com/louis-e/arnis"
@@ -101,23 +101,3 @@ suspicious = "warn"
 style = "warn"
 complexity = "warn"
 perf = "warn"
-
-
-# Later: 
-# pedantic = { level = "warn", priority = -1 }
-
-# allow_attributes = "warn"
-# allow_attributes_without_reason = "warn"
-# Allowed lints (might be reconsidered later)
-
-# cast_possible_truncation = "allow" # This is not useful as we have many intentional casts
-# cast_sign_loss = "allow"    # This is not useful as we have many intentional casts
-# inline_always = "allow" # https://rust-lang.github.io/rust-clippy/rust-1.91.0/index.html#inline_always
-# too_many_lines = "allow" # Many functions are long --> Reformatting would be better
-# match_same_arms = "allow" # Sometimes useful for clarity
-# module_name_repetitions = "allow" # Sometimes useful for clarity
-# unreadable_literal = "allow"
-# similar_names = "allow"
-# float_cmp = "allow"
-# cast_lossless = "allow"
-# fn_params_excessive_bools = "allow"

Cargo.toml

@@ -658,15 +658,15 @@ fn convert_slab(
     let mut states = HashMap::new();
 
     // Convert type: Java uses "top/bottom/double", Bedrock uses "top_slot_bit"
-    if let Some(props) = props {
-        if let Some(fastnbt::Value::String(slab_type)) = props.get("type") {
-            let top_slot = slab_type == "top";
-            states.insert(
-                "top_slot_bit".to_string(),
-                BedrockBlockStateValue::Bool(top_slot),
-            );
-            // Note: "double" slabs in Java become full blocks in Bedrock (different block ID)
-        }
+    if let Some(props) = props
+        && let Some(fastnbt::Value::String(slab_type)) = props.get("type")
+    {
+        let top_slot = slab_type == "top";
+        states.insert(
+            "top_slot_bit".to_string(),
+            BedrockBlockStateValue::Bool(top_slot),
+        );
+        // Note: "double" slabs in Java become full blocks in Bedrock (different block ID)
     }
 
     // Default to bottom if not specified
@@ -727,13 +727,13 @@ fn convert_log(
     let mut states = HashMap::new();
 
     // Convert axis: Java uses "x/y/z", Bedrock uses "pillar_axis"
-    if let Some(props) = props {
-        if let Some(fastnbt::Value::String(axis)) = props.get("axis") {
-            states.insert(
-                "pillar_axis".to_string(),
-                BedrockBlockStateValue::String(axis.clone()),
-            );
-        }
+    if let Some(props) = props
+        && let Some(fastnbt::Value::String(axis)) = props.get("axis")
+    {
+        states.insert(
+            "pillar_axis".to_string(),
+            BedrockBlockStateValue::String(axis.clone()),
+        );
     }
 
     // Default to y-axis if not specified

src/bedrock_block_map.rs

@@ -259,14 +259,14 @@ fn clip_polyline_to_bbox(nodes: &[ProcessedNode], xzbbox: &XZBBox) -> Vec<Proces
     // Preserve endpoint IDs where possible
     if result.len() >= 2 {
         let tolerance = 50.0;
-        if let Some(first_orig) = nodes.first() {
-            if matches_endpoint(
+        if let Some(first_orig) = nodes.first()
+            && matches_endpoint(
                 (f64::from(result[0].x), f64::from(result[0].z)),
                 first_orig,
                 tolerance,
-            ) {
-                result[0].id = first_orig.id;
-            }
+            )
+        {
+            result[0].id = first_orig.id;
         }
         if let Some(last_orig) = nodes.last() {
             let last_idx = result.len() - 1;
@@ -320,26 +320,12 @@ fn clip_polygon_sutherland_hodgman(
             let next_inside = point_inside_edge(next, edge_x1, edge_z1, edge_x2, edge_z2);
 
             if next_inside {
-                if !current_inside {
-                    if let Some(mut intersection) = line_edge_intersection(
+                if !current_inside
+                    && let Some(mut intersection) = line_edge_intersection(
                         current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
-                    ) {
-                        // Clamp to current edge only
-                        match edge_idx {
-                            0 => intersection.1 = min_z,
-                            1 => intersection.0 = max_x,
-                            2 => intersection.1 = max_z,
-                            3 => intersection.0 = min_x,
-                            _ => {}
-                        }
-                        clipped.push(intersection);
-                    }
-                }
-                clipped.push(next);
-            } else if current_inside {
-                if let Some(mut intersection) = line_edge_intersection(
-                    current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
-                ) {
+                    )
+                {
+                    // Clamp to current edge only
                     match edge_idx {
                         0 => intersection.1 = min_z,
                         1 => intersection.0 = max_x,
@@ -349,6 +335,20 @@ fn clip_polygon_sutherland_hodgman(
                     }
                     clipped.push(intersection);
                 }
+                clipped.push(next);
+            } else if current_inside
+                && let Some(mut intersection) = line_edge_intersection(
+                    current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
+                )
+            {
+                match edge_idx {
+                    0 => intersection.1 = min_z,
+                    1 => intersection.0 = max_x,
+                    2 => intersection.1 = max_z,
+                    3 => intersection.0 = min_x,
+                    _ => {}
+                }
+                clipped.push(intersection);
             }
         }
 
@@ -388,24 +388,24 @@ fn clip_polygon_sutherland_hodgman_simple(
             let next_inside = point_inside_edge(next, edge_x1, edge_z1, edge_x2, edge_z2);
 
             if next_inside {
-                if !current_inside {
-                    if let Some(mut intersection) = line_edge_intersection(
+                if !current_inside
+                    && let Some(mut intersection) = line_edge_intersection(
                         current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
-                    ) {
-                        intersection.0 = intersection.0.clamp(min_x, max_x);
-                        intersection.1 = intersection.1.clamp(min_z, max_z);
-                        clipped.push(intersection);
-                    }
-                }
-                clipped.push(next);
-            } else if current_inside {
-                if let Some(mut intersection) = line_edge_intersection(
-                    current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
-                ) {
+                    )
+                {
                     intersection.0 = intersection.0.clamp(min_x, max_x);
                     intersection.1 = intersection.1.clamp(min_z, max_z);
                     clipped.push(intersection);
                 }
+                clipped.push(next);
+            } else if current_inside
+                && let Some(mut intersection) = line_edge_intersection(
+                    current.0, current.1, next.0, next.1, edge_x1, edge_z1, edge_x2, edge_z2,
+                )
+            {
+                intersection.0 = intersection.0.clamp(min_x, max_x);
+                intersection.1 = intersection.1.clamp(min_z, max_z);
+                clipped.push(intersection);
             }
         }
 
@@ -632,10 +632,11 @@ fn remove_consecutive_duplicates(polygon: Vec<(f64, f64)>) -> Vec<(f64, f64)> {
     let mut result: Vec<(f64, f64)> = Vec::with_capacity(polygon.len());
 
     for p in &polygon {
-        if let Some(last) = result.last() {
-            if (p.0 - last.0).abs() < eps && (p.1 - last.1).abs() < eps {
-                continue;
-            }
+        if let Some(last) = result.last()
+            && (p.0 - last.0).abs() < eps
+            && (p.1 - last.1).abs() < eps
+        {
+            continue;
         }
         result.push(*p);
     }
@@ -682,25 +683,25 @@ fn assign_node_ids_preserving_endpoints(
             let is_last = i == last_index;
 
             if is_first || is_last {
-                if let Some(first) = original_first {
-                    if matches_endpoint(coord, first, tolerance) {
-                        return ProcessedNode {
-                            id: first.id,
-                            x: coord.0.round() as i32,
-                            z: coord.1.round() as i32,
-                            tags: HashMap::new(),
-                        };
-                    }
+                if let Some(first) = original_first
+                    && matches_endpoint(coord, first, tolerance)
+                {
+                    return ProcessedNode {
+                        id: first.id,
+                        x: coord.0.round() as i32,
+                        z: coord.1.round() as i32,
+                        tags: HashMap::new(),
+                    };
                 }
-                if let Some(last) = original_last {
-                    if matches_endpoint(coord, last, tolerance) {
-                        return ProcessedNode {
-                            id: last.id,
-                            x: coord.0.round() as i32,
-                            z: coord.1.round() as i32,
-                            tags: HashMap::new(),
-                        };
-                    }
+                if let Some(last) = original_last
+                    && matches_endpoint(coord, last, tolerance)
+                {
+                    return ProcessedNode {
+                        id: last.id,
+                        x: coord.0.round() as i32,
+                        z: coord.1.round() as i32,
+                        tags: HashMap::new(),
+                    };
                 }
             }
 

src/clipping.rs

@@ -11,7 +11,7 @@ use crate::map_renderer;
 use crate::osm_parser::ProcessedElement;
 use crate::progress::{emit_gui_progress_update, emit_map_preview_ready, emit_open_mcworld_file};
 #[cfg(feature = "gui")]
-use crate::telemetry::{send_log, LogLevel};
+use crate::telemetry::{LogLevel, send_log};
 use crate::world_editor::{WorldEditor, WorldFormat};
 use colored::Colorize;
 use indicatif::{ProgressBar, ProgressStyle};
@@ -279,39 +279,39 @@ pub fn generate_world_with_options(
 
     // Update player spawn Y coordinate based on terrain height after generation
     #[cfg(feature = "gui")]
-    if world_format == WorldFormat::JavaAnvil {
-        if let Some(spawn_coords) = &args.spawn_point {
-            use crate::gui::update_player_spawn_y_after_generation;
-            let bbox_string = format!(
-                "{},{},{},{}",
-                args.bbox.min().lng(),
-                args.bbox.min().lat(),
-                args.bbox.max().lng(),
-                args.bbox.max().lat()
-            );
-
-            if let Err(e) = update_player_spawn_y_after_generation(
-                &args.path,
-                Some(*spawn_coords),
-                bbox_string,
-                args.scale,
-                &ground,
-            ) {
-                let warning_msg = format!("Failed to update spawn point Y coordinate: {e}");
-                eprintln!("Warning: {warning_msg}");
-                #[cfg(feature = "gui")]
-                send_log(LogLevel::Warning, &warning_msg);
-            }
+    if world_format == WorldFormat::JavaAnvil
+        && let Some(spawn_coords) = &args.spawn_point
+    {
+        use crate::gui::update_player_spawn_y_after_generation;
+        let bbox_string = format!(
+            "{},{},{},{}",
+            args.bbox.min().lng(),
+            args.bbox.min().lat(),
+            args.bbox.max().lng(),
+            args.bbox.max().lat()
+        );
+
+        if let Err(e) = update_player_spawn_y_after_generation(
+            &args.path,
+            Some(*spawn_coords),
+            bbox_string,
+            args.scale,
+            &ground,
+        ) {
+            let warning_msg = format!("Failed to update spawn point Y coordinate: {e}");
+            eprintln!("Warning: {warning_msg}");
+            #[cfg(feature = "gui")]
+            send_log(LogLevel::Warning, &warning_msg);
         }
     }
 
     emit_gui_progress_update(99.0, "Finalizing world...");
 
     // For Bedrock format, emit event to open the mcworld file
-    if world_format == WorldFormat::BedrockMcWorld {
-        if let Some(path_str) = output_path.to_str() {
-            emit_open_mcworld_file(path_str);
-        }
+    if world_format == WorldFormat::BedrockMcWorld
+        && let Some(path_str) = output_path.to_str()
+    {
+        emit_open_mcworld_file(path_str);
     }
 
     // Generate top-down map preview silently in background after completion (Java only)

src/data_processing.rs

@@ -1,6 +1,6 @@
 use crate::args::Args;
 use crate::block_definitions::{
-    Block, BLACK_CONCRETE, CAULDRON, COBBLESTONE_WALL, GLOWSTONE, GRAY_CONCRETE, IRON_BLOCK,
+    BLACK_CONCRETE, Block, CAULDRON, COBBLESTONE_WALL, GLOWSTONE, GRAY_CONCRETE, IRON_BLOCK,
     LIGHT_GRAY_CONCRETE, OAK_FENCE, OAK_LOG, OAK_PLANKS, SMOOTH_STONE, STONE_BLOCK_SLAB,
     STONE_BRICK_SLAB, WATER,
 };
@@ -12,16 +12,16 @@ use crate::world_editor::WorldEditor;
 
 pub fn generate_amenities(editor: &mut WorldEditor<'_>, element: &ProcessedElement, args: &Args) {
     // Skip if 'layer' or 'level' is negative in the tags
-    if let Some(layer) = element.tags().get("layer") {
-        if layer.parse::<i32>().unwrap_or(0) < 0 {
-            return;
-        }
+    if let Some(layer) = element.tags().get("layer")
+        && layer.parse::<i32>().unwrap_or(0) < 0
+    {
+        return;
     }
 
-    if let Some(level) = element.tags().get("level") {
-        if level.parse::<i32>().unwrap_or(0) < 0 {
-            return;
-        }
+    if let Some(level) = element.tags().get("level")
+        && level.parse::<i32>().unwrap_or(0) < 0
+    {
+        return;
     }
 
     if let Some(amenity_type) = element.tags().get("amenity") {

src/element_processing/amenities.rs

@@ -1,5 +1,5 @@
 use crate::block_definitions::{
-    Block, AIR, BRICK, COBBLESTONE_WALL, GLASS, LIGHT_GRAY_CONCRETE, OAK_FENCE, OAK_LEAVES, STONE,
+    AIR, BRICK, Block, COBBLESTONE_WALL, GLASS, LIGHT_GRAY_CONCRETE, OAK_FENCE, OAK_LEAVES, STONE,
     STONE_BRICK_SLAB, STONE_BRICK_WALL,
 };
 use crate::bresenham::bresenham_line;