Manually ignore warnings

factorio-blueprint-generator/src/bin/generate_factory.rs

@@ -42,6 +42,7 @@ enum Tracing {
 }
 
 #[derive(ValueEnum, Clone, Copy)]
+#[allow(clippy::enum_variant_names)]
 enum PathfinderArg {
     CaFbh,
     CaBh,

factorio-blueprint-generator/src/multistation.rs

@@ -3,7 +3,7 @@ use crate::{
     station::{StationBasicSpec, basic_station},
 };
 use factorio_blueprint::abstraction::{
-    Blueprint, ElectricPoleType, Entity, Quality, RailType, UndergroundType,
+    Blueprint, ElectricPoleType, Entity, RailType, UndergroundType,
 };
 use factorio_core::{
     beltoptions::{Beltspeed, Belttype},

factorio-blueprint-generator/src/station.rs

@@ -223,6 +223,7 @@ pub fn one_loader(
     (b, -6)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn basic_station(
     load: bool,
     locomotives: usize,

factorio-blueprint-generator/src/subfactory/assembling_line.rs

@@ -161,11 +161,7 @@ pub fn assembly_line(
     };
 
     let belt3 = (Direction::Right, input_belt1);
-    let belt4 = if let Some(input_belt2) = input_belt2 {
+    let belt4 = input_belt2.map(|input_belt2| (Direction::Right, input_belt2));
-        Some((Direction::Right, input_belt2))
-    } else {
-        None
-    };
 
     for i in 0..(3 * (assembly_machines - 1) + 1) {
         if let Some((d, t)) = belt1 {

factorio-blueprint/src/abstraction/power_connection.rs

@@ -8,6 +8,7 @@ use super::*;
 
 #[derive(Debug)]
 struct PowerGraph {
+    #[allow(clippy::type_complexity)]
     nodes: HashMap<(Position, ElectricPoleType), (Vec<(Position, ElectricPoleType)>, i64)>,
 }
 
@@ -254,7 +255,7 @@ impl Blueprint {
             })
             .collect::<Vec<_>>();
 
-        if roboportmap.len() == 0 {
+        if roboportmap.is_empty() {
             return;
         } else if roboportmap.len() == 1 {
             let roboport = roboportmap.into_iter().next().unwrap();
@@ -297,14 +298,15 @@ impl Blueprint {
                 {
                     // dbg!(x, y, electric_pole_type);
                     let alignment = electric_pole_type.alignment();
-                    if x.rem_euclid(2) == alignment && y.rem_euclid(2) == alignment {
+                    if x.rem_euclid(2) == alignment
-                        if placibility.placeable(Position::new(x, y), electric_pole_type.size()) {
+                        && y.rem_euclid(2) == alignment
-                            start_nodes.push(Node {
+                        && placibility.placeable(Position::new(x, y), electric_pole_type.size())
-                                pos: Position::new(x, y),
+                    {
-                                electric_pole_type,
+                        start_nodes.push(Node {
-                                node_type: NodeType::In,
+                            pos: Position::new(x, y),
-                            });
+                            electric_pole_type,
-                        }
+                            node_type: NodeType::In,
+                        });
                     }
                 }
             }

factorio-blueprint/src/abstraction/serde.rs

@@ -61,7 +61,7 @@ impl Serialize for SerialzeEntitiesWrapper<'_> {
         let mut entity_array = serializer.serialize_seq(Some(self.0.len()))?;
 
         for (i, (_, e)) in self.0.iter().enumerate() {
-            entity_array.serialize_element(&SerializeEntityWrapper(i + 1, &e))?;
+            entity_array.serialize_element(&SerializeEntityWrapper(i + 1, e))?;
         }
 
         entity_array.end()
@@ -135,11 +135,9 @@ impl Serialize for SerializeEntityWrapper<'_> {
             }
             super::EntityType::Inserter {
                 inserter_type: _,
-                override_stack_size,
+                override_stack_size: Some(stack_size),
             } => {
-                if let Some(stack_size) = override_stack_size {
+                entity_map.serialize_entry("override_stack_size", stack_size)?;
-                    entity_map.serialize_entry("override_stack_size", stack_size)?;
-                }
             }
             super::EntityType::Production {
                 name: _,

factorio-graph/src/priority_queue/bucket_queue.rs

@@ -11,13 +11,13 @@ pub struct BucketQueue<Item> {
 impl<Item> std::fmt::Debug for BucketQueue<Item> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         struct DebugWrapper2<'a, I>(&'a Vec<(usize, I)>);
-        impl<'a, I> std::fmt::Debug for DebugWrapper2<'a, I> {
+        impl<I> std::fmt::Debug for DebugWrapper2<'_, I> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 f.debug_list().entries(self.0.iter().map(|v| v.0)).finish()
             }
         }
         struct DebugWrapper<'a, I>(&'a VecDeque<Vec<(usize, I)>>);
-        impl<'a, I> std::fmt::Debug for DebugWrapper<'a, I> {
+        impl<I> std::fmt::Debug for DebugWrapper<'_, I> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 f.debug_list()
                     .entries(self.0.iter().map(|v| DebugWrapper2(v)))

factorio-graph/src/set_cover.rs

@@ -28,7 +28,7 @@ pub fn greedy_set_cover_simple<S>(universe: usize, sets: &[S]) -> Vec<usize>
 where
     S: Deref<Target = [usize]>,
 {
-    assert!(sets.len() > 0);
+    assert!(!sets.is_empty());
 
     let mut r = Vec::new();
 

factorio-graph/src/wheighted_graph/shortest_path.rs

@@ -15,9 +15,9 @@ impl<N> QueueObject<N> {
     }
 }
 
-impl<N> Into<i64> for &QueueObject<N> {
+impl<N> From<&QueueObject<N>> for i64 {
-    fn into(self) -> i64 {
+    fn from(val: &QueueObject<N>) -> Self {
-        self.score
+        val.score
     }
 }
 

factorio-pathfinding/src/bin/path_finding.rs

@@ -24,6 +24,7 @@ struct Args {
 }
 
 #[derive(ValueEnum, Clone, Copy)]
+#[allow(clippy::enum_variant_names)]
 enum PathfinderArg {
     CaFbh,
     CaBh,
@@ -108,7 +109,7 @@ fn main() {
     }
 }
 
-fn execute<'a, M: Map>(args: &Args, path_input: PathInput<'a, M>) {
+fn execute<M: Map>(args: &Args, path_input: PathInput<'_, M>) {
     match args.pathfinder {
         PathfinderArg::CaFbh => {
             let p = ConflictAvoidance {