Run clippy

src/coords.rs

@@ -2,7 +2,7 @@
 
 use std::fmt;
 use std::fmt::Formatter;
-use std::ops::Add;
+
 
 use cgmath::num_traits::Pow;
 use cgmath::{AbsDiffEq, Matrix4, Point3, Vector3};

src/input/mod.rs

@@ -13,8 +13,8 @@ use crate::input::tilt_handler::TiltHandler;
 use crate::input::zoom_handler::ZoomHandler;
 use crate::map_state::MapState;
 
-use crate::render::render_state::RenderState;
-use crate::Scheduler;
+
+
 
 mod pan_handler;
 mod pinch_handler;

src/input/pan_handler.rs

@@ -2,8 +2,8 @@ use super::UpdateState;
 
 use crate::map_state::MapState;
 use crate::render::camera::Camera;
-use crate::render::render_state::RenderState;
-use crate::Scheduler;
+
+
 use cgmath::{EuclideanSpace, Point3, Vector2, Vector3, Zero};
 use std::time::Duration;
 use winit::event::{ElementState, MouseButton};
@@ -17,7 +17,7 @@ pub struct PanHandler {
 }
 
 impl UpdateState for PanHandler {
-    fn update_state<W>(&mut self, state: &mut MapState<W>, dt: Duration) {
+    fn update_state<W>(&mut self, state: &mut MapState<W>, _dt: Duration) {
         if !self.is_panning {
             return;
         }

src/input/pinch_handler.rs

@@ -1,13 +1,13 @@
 use super::UpdateState;
 
-use crate::render::render_state::RenderState;
-use crate::{MapState, Scheduler};
+
+use crate::{MapState};
 use std::time::Duration;
 
 pub struct PinchHandler {}
 
 impl UpdateState for PinchHandler {
-    fn update_state<W>(&mut self, state: &mut MapState<W>, dt: Duration) {
+    fn update_state<W>(&mut self, _state: &mut MapState<W>, _dt: Duration) {
         // TODO
     }
 }

src/input/query_handler.rs

@@ -1,6 +1,6 @@
-use crate::render::render_state::RenderState;
 
-use crate::Scheduler;
+
+
 use cgmath::Vector2;
 
 use crate::coords::WorldCoords;
@@ -60,7 +60,7 @@ impl QueryHandler {
 }
 
 impl UpdateState for QueryHandler {
-    fn update_state<W>(&mut self, state: &mut MapState<W>, dt: Duration) {
+    fn update_state<W>(&mut self, state: &mut MapState<W>, _dt: Duration) {
         if self.clicking {
             if let Some(window_position) = self.window_position {
                 let perspective = &state.perspective();

src/input/shift_handler.rs

@@ -1,7 +1,7 @@
 use super::UpdateState;
 
-use crate::render::render_state::RenderState;
-use crate::{MapState, Scheduler};
+
+use crate::{MapState};
 use cgmath::{Vector3, Zero};
 use std::time::Duration;
 

src/input/tilt_handler.rs

@@ -1,8 +1,8 @@
 use super::UpdateState;
 
 use crate::map_state::MapState;
-use crate::render::render_state::RenderState;
-use crate::Scheduler;
+
+
 use cgmath::{Deg, Rad, Zero};
 use std::time::Duration;
 

src/input/zoom_handler.rs

@@ -2,9 +2,9 @@ use super::UpdateState;
 
 use crate::coords::Zoom;
 use crate::map_state::MapState;
-use crate::render::render_state::RenderState;
-use crate::Scheduler;
-use cgmath::num_traits::Pow;
+
+
+
 use cgmath::{Vector2, Vector3};
 use std::time::Duration;
 
@@ -15,7 +15,7 @@ pub struct ZoomHandler {
 }
 
 impl UpdateState for ZoomHandler {
-    fn update_state<W>(&mut self, state: &mut MapState<W>, dt: Duration) {
+    fn update_state<W>(&mut self, state: &mut MapState<W>, _dt: Duration) {
         if let Some(zoom_delta) = self.zoom_delta {
             if let Some(window_position) = self.window_position {
                 let current_zoom = state.zoom();

src/io/geometry_index.rs

@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, HashMap};
 
-use cgmath::num_traits::{Pow, Signed};
+use cgmath::num_traits::{Signed};
 use cgmath::Bounded;
 use geo::prelude::*;
 use geo_types::{CoordFloat, Coordinate, Geometry, LineString, Point, Polygon};

src/io/scheduler.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::{HashSet};
 use std::future::Future;
 
 use geozero::mvt::Tile;
@@ -157,7 +157,7 @@ impl ThreadLocalState {
         z: u8,
         zoom: Zoom,
     ) -> Option<Vec<IndexedGeometry<f64>>> {
-        if let Ok(mut geometry_index) = self.geometry_index.lock() {
+        if let Ok(geometry_index) = self.geometry_index.lock() {
             geometry_index
                 .query_point(world_coords, z, zoom)
                 .map(|geometries| {

src/lib.rs

@@ -1,5 +1,5 @@
 use crate::io::scheduler::Scheduler;
-use std::future::Future;
+
 
 mod input;
 
@@ -17,7 +17,7 @@ pub(crate) mod winit;
 pub mod benchmarking;
 
 use crate::map_state::{MapState, Runnable};
-use crate::render::render_state::{RenderState, SurfaceFactory};
+use crate::render::render_state::{RenderState};
 pub use io::scheduler::ScheduleMethod;
 pub use platform::schedule_method::*;
 use style_spec::Style;

src/map_state.rs

@@ -1,15 +1,15 @@
 use crate::coords::{ViewRegion, Zoom, TILE_SIZE};
-use crate::input::{InputController, UpdateState};
+
 use crate::io::scheduler::Scheduler;
-use crate::io::LayerTessellateMessage;
+
 use crate::render::camera;
-use crate::render::camera::{Camera, Perspective, ViewProjection};
+use crate::render::camera::{Camera, Perspective};
 use crate::render::render_state::RenderState;
 use crate::util::ChangeObserver;
-use crate::{SurfaceFactory, WindowSize};
+use crate::{WindowSize};
 use std::collections::HashSet;
-use std::iter;
-use std::time::Duration;
+
+
 use style_spec::Style;
 use wgpu::SurfaceError;
 

src/render/camera.rs

@@ -1,7 +1,7 @@
 use cgmath::prelude::*;
 use cgmath::{AbsDiffEq, Matrix4, Point2, Point3, Vector2, Vector3, Vector4};
 
-use crate::render::shaders::ShaderCamera;
+
 use crate::util::math::{bounds_from_points, Aabb2, Aabb3, Plane};
 use crate::util::SignificantlyDifferent;
 

src/render/render_state.rs

@@ -1,7 +1,7 @@
-use std::collections::HashSet;
+
 use std::default::Default;
 
-use cgmath::AbsDiffEq;
+
 use std::{cmp, iter};
 
 use tracing;
@@ -9,21 +9,21 @@ use wgpu::{Buffer, Limits, Queue, Surface, SurfaceConfiguration};
 
 use style_spec::Style;
 
-use crate::coords::{ViewRegion, Zoom, TILE_SIZE};
-use crate::io::scheduler::Scheduler;
+use crate::coords::{ViewRegion, Zoom};
+
 use crate::io::tile_cache::TileCache;
 use crate::io::LayerTessellateMessage;
-use crate::platform::{COLOR_TEXTURE_FORMAT, MIN_BUFFER_SIZE};
+use crate::platform::{MIN_BUFFER_SIZE};
 use crate::render::buffer_pool::{BackingBufferDescriptor, BufferPool, IndexEntry};
-use crate::render::camera;
-use crate::render::camera::{Camera, Perspective, ViewProjection};
+
+use crate::render::camera::{Camera, ViewProjection};
 use crate::render::options::{
     DEBUG_WIREFRAME, FEATURE_METADATA_BUFFER_SIZE, INDEX_FORMAT, INDICES_BUFFER_SIZE,
     LAYER_METADATA_BUFFER_SIZE, TILE_VIEW_BUFFER_SIZE, VERTEX_BUFFER_SIZE,
 };
 use crate::render::tile_view_pattern::{TileInView, TileViewPattern};
 use crate::tessellation::IndexDataType;
-use crate::util::{ChangeObserver, FPSMeter};
+use crate::util::{FPSMeter};
 use crate::WindowSize;
 
 use super::piplines::*;

src/render/tile_view_pattern.rs

@@ -1,5 +1,5 @@
 use crate::coords::{ViewRegion, WorldTileCoords, Zoom};
-use crate::io::tile_cache::TileCache;
+
 use crate::render::buffer_pool::{BackingBufferDescriptor, BufferPool, Queue};
 use crate::render::camera::ViewProjection;
 use crate::render::shaders::{ShaderFeatureStyle, ShaderLayerMetadata, ShaderTileMetadata};

src/util/mod.rs

@@ -83,11 +83,7 @@ where
 
     pub fn did_change(&self, epsilon: T::Epsilon) -> bool {
         if let Some(reference_value) = &self.reference_value {
-            if reference_value.ne(&self.inner, epsilon) {
-                true
-            } else {
-                false
-            }
+            reference_value.ne(&self.inner, epsilon)
         } else {
             true
         }

src/winit.rs

@@ -7,14 +7,12 @@ use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEve
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::WindowBuilder;
 
-use style_spec::Style;
-
 use crate::input::{InputController, UpdateState};
-use crate::io::scheduler::Scheduler;
+
 use crate::map_state::{MapState, Runnable};
 use crate::platform::Instant;
-use crate::render::render_state::RenderState;
-use crate::{FromCanvas, FromWindow, MapBuilder, WindowSize};
+
+use crate::{FromWindow, MapBuilder, WindowSize};
 
 impl Runnable<winit::event_loop::EventLoop<()>> for MapState<winit::window::Window> {
     fn run(mut self, event_loop: winit::event_loop::EventLoop<()>, max_frames: Option<u64>) {
@@ -160,7 +158,7 @@ pub fn get_canvas(element_id: &'static str) -> web_sys::HtmlCanvasElement {
 }
 
 #[cfg(target_arch = "wasm32")]
-impl FromCanvas for MapBuilder<winit::window::Window, winit::event_loop::EventLoop<()>> {
+impl crate::FromCanvas for MapBuilder<winit::window::Window, winit::event_loop::EventLoop<()>> {
     fn from_canvas(dom_id: &'static str) -> Self {
         let event_loop = EventLoop::new();
         Self::new(Box::new(move || {