allow clippy in vendored spade

Author: mockersf

src/vendored_spade/delaunay_core/bulk_load.rs

@@ -91,10 +91,6 @@ where
         );
     }
 
-    if cfg!(any(fuzzing, test)) {
-        hull_sanity_check(&result, &hull);
-    }
-
     fix_convexity(&mut result);
 
     for element in skipped_elements {
@@ -252,10 +248,6 @@ where
 
     assert_eq!(edges.len(), 0);
 
-    if cfg!(any(fuzzing, test)) {
-        hull_sanity_check(&result, &hull);
-    }
-
     Ok(result)
 }
 
@@ -777,10 +769,6 @@ impl Hull {
                     break;
                 }
 
-                if cfg!(any(fuzzing, test)) {
-                    assert!(!self.empty.contains(&right_index));
-                }
-
                 // Remove current_node - it is completely overlapped by the new segment
                 self.empty.push(right_index);
                 self.data[current_node.left].right = current_node.right;

src/vendored_spade/delaunay_core/dcel.rs

@@ -389,52 +389,4 @@ impl<V, DE, UE, F> Dcel<V, DE, UE, F> {
             }
         }
     }
-
-    #[cfg(any(test, fuzzing))]
-    pub fn sanity_check(&self) {
-        if self.num_vertices() <= 1 {
-            assert_eq!(self.num_faces(), 1);
-            assert_eq!(self.num_undirected_edges(), 0);
-            assert!(
-                self.faces[super::dcel_operations::OUTER_FACE_HANDLE.index()]
-                    .adjacent_edge
-                    .is_none()
-            );
-            return;
-        }
-
-        for (index, face) in self.faces.iter().enumerate() {
-            assert_eq!(
-                self.directed_edge(face.adjacent_edge.unwrap()).face().fix(),
-                FixedFaceHandle::new(index)
-            );
-        }
-        for (index, vertex) in self.vertices.iter().enumerate() {
-            assert_eq!(
-                self.directed_edge(vertex.out_edge.unwrap()).from().fix(),
-                FixedVertexHandle::new(index)
-            );
-        }
-
-        for handle in 0..self.edges.len() {
-            let edge = self.directed_edge(FixedDirectedEdgeHandle::new_normalized(handle));
-            assert_eq!(edge, edge.next().prev());
-            assert_eq!(edge, edge.prev().next());
-            assert_eq!(edge, edge.rev().rev());
-            if self.num_faces() > 1 {
-                assert_ne!(edge.face(), edge.rev().face());
-            }
-            if !edge.face().is_outer() {
-                assert_eq!(edge, edge.next().next().next());
-                assert_eq!(edge, edge.prev().prev().prev());
-            }
-            assert_ne!(edge, edge.next());
-            assert_ne!(edge, edge.prev());
-
-            assert_eq!(edge, edge.cw().ccw());
-            assert_eq!(edge, edge.ccw().cw());
-            assert_eq!(edge.from(), edge.cw().from());
-            assert_eq!(edge.from(), edge.ccw().from());
-        }
-    }
 }

src/vendored_spade/delaunay_core/triangulation_ext.rs

@@ -736,81 +736,4 @@ pub trait TriangulationExt: Triangulation {
             }
         }
     }
-
-    #[cfg(any(test, fuzzing))]
-    fn basic_sanity_check(&self, check_convexity: bool) {
-        self.s().sanity_check();
-        let all_vertices_on_line = self.s().num_faces() <= 1;
-
-        for face in self.s().inner_faces() {
-            let triangle = face.vertices();
-            // Check that all vertices are stored in ccw orientation
-            assert!(math::side_query(
-                triangle[0].position(),
-                triangle[1].position(),
-                triangle[2].position()
-            )
-            .is_on_left_side(),);
-        }
-
-        for edge in self.s().directed_edges() {
-            if all_vertices_on_line {
-                assert_eq!(edge.face().fix(), dcel_operations::OUTER_FACE_HANDLE)
-            } else {
-                assert_ne!(edge.face(), edge.rev().face());
-            }
-            assert_ne!(edge.from(), edge.to());
-        }
-
-        if all_vertices_on_line {
-            if self.s().num_vertices() > 1 {
-                assert_eq!(self.s().num_undirected_edges(), self.s().num_vertices() - 1);
-            } else {
-                assert_eq!(self.s().num_undirected_edges(), 0);
-            }
-            assert_eq!(self.s().num_faces(), 1);
-        } else {
-            let num_inner_edges = self
-                .s()
-                .directed_edges()
-                .filter(|e| !e.face().is_outer())
-                .count();
-
-            let num_inner_faces = self.s().num_faces() - 1;
-            assert_eq!(num_inner_faces * 3, num_inner_edges);
-
-            if check_convexity {
-                for edge in self.convex_hull() {
-                    for vert in self.vertices() {
-                        assert!(edge
-                            .side_query(vert.position())
-                            .is_on_right_side_or_on_line(),);
-                    }
-                }
-            }
-        }
-    }
-
-    #[cfg(any(test, fuzzing))]
-    fn sanity_check(&self) {
-        self.basic_sanity_check(true);
-
-        for edge in self.undirected_edges() {
-            let edge = edge.as_directed();
-            let rev = edge.rev();
-
-            if let (Some(edge_opposite), Some(rev_opposite)) =
-                (edge.opposite_position(), rev.opposite_position())
-            {
-                let from = edge.from().position();
-                let to = edge.to().position();
-                assert!(!math::contained_in_circumference(
-                    from,
-                    to,
-                    edge_opposite,
-                    rev_opposite
-                ))
-            }
-        }
-    }
 }

src/vendored_spade/mod.rs

@@ -21,7 +21,9 @@
 //!    `mint::Point2`. Also implements [HasPosition] for `mint::Point2`.
 
 #![forbid(unsafe_code)]
-#![warn(clippy::all)]
+#![allow(clippy::all)]
+#![allow(unused_imports)]
+#![allow(dead_code)]
 #![deny(rustdoc::broken_intra_doc_links)]
 
 extern crate alloc;