Apply clippy lints (#278)

TrueDoctor · web-flow · commit 4637cbf12bbe · 2021-07-17T11:12:37.000+02:00
diff --git a/core/document/src/document.rs b/core/document/src/document.rs
@@ -67,7 +67,6 @@ impl Document {
 	/// Checks whether each layer under `path` intersects with the provided `quad` and adds all intersection layers as paths to `intersections`.
 	pub fn intersects_quad(&self, quad: [DVec2; 4], path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
 		self.document_folder(path).unwrap().intersects_quad(quad, path, intersections);
-		return;
 	}
 
 	/// Checks whether each layer under the root path intersects with the provided `quad` and returns the paths to all intersecting layers.
@@ -229,7 +228,7 @@ impl Document {
 
 	pub fn layer_axis_aligned_bounding_box(&self, path: &[LayerId]) -> Result<Option<[DVec2; 2]>, DocumentError> {
 		// TODO: Replace with functions of the transform api
-		if let &[] = path {
+		if path.is_empty() {
 			// Special case for root. Root's local is the documents global, so we avoid transforming its transform by itself.
 			self.layer_local_bounding_box(path)
 		} else {
@@ -265,13 +264,13 @@ impl Document {
 				Some(vec![DocumentResponse::DocumentChanged, DocumentResponse::SelectLayer { path }])
 			}
 			Operation::AddRect { path, insert_index, transform, style } => {
-				let id = self.add_layer(&path, Layer::new(LayerDataTypes::Rect(Rect::new()), *transform, *style), *insert_index)?;
+				let id = self.add_layer(&path, Layer::new(LayerDataTypes::Rect(Rect), *transform, *style), *insert_index)?;
 				let path = [path.clone(), vec![id]].concat();
 
 				Some(vec![DocumentResponse::DocumentChanged, DocumentResponse::SelectLayer { path }])
 			}
 			Operation::AddLine { path, insert_index, transform, style } => {
-				let id = self.add_layer(&path, Layer::new(LayerDataTypes::Line(Line::new()), *transform, *style), *insert_index)?;
+				let id = self.add_layer(&path, Layer::new(LayerDataTypes::Line(Line), *transform, *style), *insert_index)?;
 				let path = [path.clone(), vec![id]].concat();
 
 				Some(vec![DocumentResponse::DocumentChanged, DocumentResponse::SelectLayer { path }])
diff --git a/core/document/src/layers/folder.rs b/core/document/src/layers/folder.rs
@@ -105,9 +105,7 @@ impl Folder {
 	pub fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {
 		let mut layers_non_empty_bounding_boxes = self.layers.iter().filter_map(|layer| layer.bounding_box(transform * layer.transform, layer.style)).peekable();
 
-		if layers_non_empty_bounding_boxes.peek().is_none() {
-			return None;
-		}
+		layers_non_empty_bounding_boxes.peek()?;
 
 		let mut x_min = f64::MAX;
 		let mut y_min = f64::MAX;
@@ -128,7 +126,7 @@ impl Folder {
 				y_max = bounding_box_max.y
 			}
 		}
-		return Some([DVec2::new(x_min, y_min), DVec2::new(x_max, y_max)]);
+		Some([DVec2::new(x_min, y_min), DVec2::new(x_max, y_max)])
 	}
 }
 
diff --git a/core/document/src/layers/line.rs b/core/document/src/layers/line.rs
@@ -11,14 +11,8 @@ use super::LayerData;
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
 
-#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
-pub struct Line {}
-
-impl Line {
-	pub fn new() -> Line {
-		Line {}
-	}
-}
+#[derive(Debug, Default, Clone, Copy, PartialEq, Deserialize, Serialize)]
+pub struct Line;
 
 impl LayerData for Line {
 	fn to_kurbo_path(&self, transform: glam::DAffine2, _style: style::PathStyle) -> kurbo::BezPath {
diff --git a/core/document/src/layers/mod.rs b/core/document/src/layers/mod.rs
@@ -135,7 +135,7 @@ impl Layer {
 			name: None,
 			data,
 			transform: glam::DAffine2::from_cols_array(&transform),
-			style: style,
+			style,
 			cache: String::new(),
 			cache_dirty: true,
 		}
@@ -171,7 +171,7 @@ impl Layer {
 		*svg += self.render();
 	}
 
-	pub fn to_kurbo_path(&mut self) -> BezPath {
+	pub fn to_kurbo_path(&self) -> BezPath {
 		self.data.to_kurbo_path(self.transform, self.style)
 	}
 
@@ -198,9 +198,8 @@ impl Layer {
 	}
 
 	pub fn render_as_folder(&mut self, svg: &mut String) {
-		match &mut self.data {
-			LayerDataTypes::Folder(f) => f.render(svg, self.transform, self.style),
-			_ => {}
+		if let LayerDataTypes::Folder(f) = &mut self.data {
+			f.render(svg, self.transform, self.style)
 		}
 	}
 }
diff --git a/core/document/src/layers/rect.rs b/core/document/src/layers/rect.rs
@@ -11,14 +11,8 @@ use super::LayerData;
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct Rect {}
-
-impl Rect {
-	pub fn new() -> Rect {
-		Rect {}
-	}
-}
+#[derive(Debug, Default, Clone, PartialEq, Deserialize, Serialize)]
+pub struct Rect;
 
 impl LayerData for Rect {
 	fn to_kurbo_path(&self, transform: glam::DAffine2, _style: style::PathStyle) -> kurbo::BezPath {
diff --git a/core/document/src/layers/shape.rs b/core/document/src/layers/shape.rs
@@ -31,9 +31,7 @@ impl LayerData for Shape {
 		let mut path = kurbo::BezPath::new();
 		let apothem_offset_angle = std::f64::consts::PI / (self.sides as f64);
 
-		let relative_points = (0..self.sides)
-			.map(|i| apothem_offset_angle * ((i * 2 + ((self.sides + 1) % 2)) as f64))
-			.map(|radians| unit_rotation(radians));
+		let relative_points = (0..self.sides).map(|i| apothem_offset_angle * ((i * 2 + ((self.sides + 1) % 2)) as f64)).map(unit_rotation);
 
 		let (mut min_x, mut min_y, mut max_x, mut max_y) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
 		relative_points.clone().for_each(|p| {
@@ -52,7 +50,7 @@ impl LayerData for Shape {
 				}
 			})
 			.map(|p| DVec2::new(p.x / 2. + 0.5, p.y / 2. + 0.5))
-			.map(|unit| transform.transform_point2(unit.into()))
+			.map(|unit| transform.transform_point2(unit))
 			.map(|pos| kurbo::Point::new(pos.x, pos.y))
 			.enumerate()
 			.for_each(|(i, p)| {
diff --git a/core/editor/src/document/document_file.rs b/core/editor/src/document/document_file.rs
@@ -108,7 +108,7 @@ impl LayerData {
 		let offset_transform = DAffine2::from_translation(offset);
 		let scale_transform = DAffine2::from_scale(DVec2::new(self.scale, self.scale));
 		let angle_transform = DAffine2::from_angle(self.snapped_angle());
-		let translation_transform = DAffine2::from_translation(self.translation.into());
+		let translation_transform = DAffine2::from_translation(self.translation);
 		scale_transform * offset_transform * angle_transform * scale_transform * translation_transform
 	}
 	pub fn calculate_transform(&self) -> DAffine2 {
diff --git a/core/editor/src/document/document_message_handler.rs b/core/editor/src/document/document_message_handler.rs
@@ -110,7 +110,7 @@ impl DocumentMessageHandler {
 		self.active_document().layer_data.get(path).expect("Layerdata does not exist")
 	}
 	fn layerdata_mut(&mut self, path: &[LayerId]) -> &mut LayerData {
-		self.active_document_mut().layer_data.entry(path.to_vec()).or_insert(LayerData::new(true))
+		self.active_document_mut().layer_data.entry(path.to_vec()).or_insert_with(|| LayerData::new(true))
 	}
 	#[allow(dead_code)]
 	fn create_transform_from_layerdata(&self, path: Vec<u64>, responses: &mut VecDeque<Message>) {
@@ -124,8 +124,8 @@ impl DocumentMessageHandler {
 		);
 	}
 	fn create_document_transform_from_layerdata(&self, viewport_size: &ViewportPosition, responses: &mut VecDeque<Message>) {
-		let half_viewport = viewport_size.to_dvec2() / 2.;
-		let layerdata = self.layerdata(&vec![]);
+		let half_viewport = viewport_size.as_dvec2() / 2.;
+		let layerdata = self.layerdata(&[]);
 		let scaled_half_viewport = half_viewport / layerdata.scale;
 		responses.push_back(
 			DocumentOperation::SetLayerTransform {
@@ -159,7 +159,7 @@ impl DocumentMessageHandler {
 			.collect();
 
 		layers_with_indices.sort_by_key(|(_, indices)| indices.clone());
-		return layers_with_indices.into_iter().map(|(path, _)| path).collect();
+		layers_with_indices.into_iter().map(|(path, _)| path).collect()
 	}
 }
 
@@ -274,7 +274,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 						}
 					})
 					.collect::<Vec<usize>>();
-				doc_title_numbers.sort();
+				doc_title_numbers.sort_unstable();
 				let mut new_doc_title_num = 1;
 				while new_doc_title_num <= self.documents.len() {
 					if new_doc_title_num != doc_title_numbers[new_doc_title_num - 1] {
@@ -430,7 +430,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 			RotateCanvasBegin { snap } => {
 				self.rotating = true;
 				self.snapping = snap;
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				layerdata.snap_rotate = snap;
 				self.mouse_pos = ipp.mouse.position;
 			}
@@ -441,7 +441,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 				self.mouse_pos = ipp.mouse.position;
 			}
 			TranslateCanvasEnd => {
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				layerdata.rotation = layerdata.snapped_angle();
 				layerdata.snap_rotate = false;
 				self.translating = false;
@@ -450,23 +450,23 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 			}
 			MouseMove => {
 				if self.translating {
-					let delta = ipp.mouse.position.to_dvec2() - self.mouse_pos.to_dvec2();
+					let delta = ipp.mouse.position.as_dvec2() - self.mouse_pos.as_dvec2();
 					let transformed_delta = self.active_document().document.root.transform.inverse().transform_vector2(delta);
 
-					let layerdata = self.layerdata_mut(&vec![]);
-					layerdata.translation = layerdata.translation + transformed_delta;
+					let layerdata = self.layerdata_mut(&[]);
+					layerdata.translation += transformed_delta;
 					self.create_document_transform_from_layerdata(&ipp.viewport_size, responses);
 				}
 				if self.rotating {
-					let half_viewport = ipp.viewport_size.to_dvec2() / 2.;
+					let half_viewport = ipp.viewport_size.as_dvec2() / 2.;
 					let rotation = {
-						let start_vec = self.mouse_pos.to_dvec2() - half_viewport;
-						let end_vec = ipp.mouse.position.to_dvec2() - half_viewport;
+						let start_vec = self.mouse_pos.as_dvec2() - half_viewport;
+						let end_vec = ipp.mouse.position.as_dvec2() - half_viewport;
 						start_vec.angle_between(end_vec)
 					};
 
 					let snapping = self.snapping;
-					let layerdata = self.layerdata_mut(&vec![]);
+					let layerdata = self.layerdata_mut(&[]);
 					layerdata.rotation += rotation;
 					layerdata.snap_rotate = snapping;
 					responses.push_back(
@@ -480,7 +480,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 				if self.zooming {
 					let difference = self.mouse_pos.y as f64 - ipp.mouse.position.y as f64;
 					let amount = 1. + difference * MOUSE_ZOOM_RATE;
-					let layerdata = self.layerdata_mut(&vec![]);
+					let layerdata = self.layerdata_mut(&[]);
 					let new = (layerdata.scale * amount).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
 					layerdata.scale = new;
 					responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
@@ -489,22 +489,22 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 				self.mouse_pos = ipp.mouse.position;
 			}
 			SetCanvasZoom(new) => {
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				layerdata.scale = new.clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
 				responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
 				self.create_document_transform_from_layerdata(&ipp.viewport_size, responses);
 			}
 			MultiplyCanvasZoom(multiplier) => {
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				let new = (layerdata.scale * multiplier).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
 				layerdata.scale = new;
 				responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
 				self.create_document_transform_from_layerdata(&ipp.viewport_size, responses);
 			}
 			WheelCanvasZoom => {
 				let scroll = ipp.mouse.scroll_delta.scroll_delta();
-				let mouse = ipp.mouse.position.to_dvec2();
-				let viewport_size = ipp.viewport_size.to_dvec2();
+				let mouse = ipp.mouse.position.as_dvec2();
+				let viewport_size = ipp.viewport_size.as_dvec2();
 				let mut zoom_factor = 1. + scroll.abs() * WHEEL_ZOOM_RATE;
 				if ipp.mouse.scroll_delta.y > 0 {
 					zoom_factor = 1. / zoom_factor
@@ -515,7 +515,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 				let delta = delta_size * -2. * (mouse_percent - (0.5, 0.5).into());
 
 				let transformed_delta = self.active_document().document.root.transform.inverse().transform_vector2(delta);
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				let new = (layerdata.scale * zoom_factor).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
 				layerdata.scale = new;
 				layerdata.translation += transformed_delta;
@@ -524,16 +524,16 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 			}
 			WheelCanvasTranslate { use_y_as_x } => {
 				let delta = match use_y_as_x {
-					false => -ipp.mouse.scroll_delta.to_dvec2(),
+					false => -ipp.mouse.scroll_delta.as_dvec2(),
 					true => (-ipp.mouse.scroll_delta.y as f64, 0.).into(),
 				} * VIEWPORT_SCROLL_RATE;
 				let transformed_delta = self.active_document().document.root.transform.inverse().transform_vector2(delta);
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				layerdata.translation += transformed_delta;
 				self.create_document_transform_from_layerdata(&ipp.viewport_size, responses);
 			}
 			SetCanvasRotation(new) => {
-				let layerdata = self.layerdata_mut(&vec![]);
+				let layerdata = self.layerdata_mut(&[]);
 				layerdata.rotation = new;
 				self.create_document_transform_from_layerdata(&ipp.viewport_size, responses);
 				responses.push_back(FrontendMessage::SetCanvasRotation { new_radians: new }.into());
@@ -542,7 +542,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
 				let paths: Vec<Vec<LayerId>> = self.selected_layers_sorted();
 
 				let delta = {
-					let root_layer_rotation = self.layerdata_mut(&vec![]).rotation;
+					let root_layer_rotation = self.layerdata_mut(&[]).rotation;
 					let rotate_to_viewport_space = DAffine2::from_angle(root_layer_rotation).inverse();
 					rotate_to_viewport_space.transform_point2((x, y).into())
 				};
diff --git a/core/editor/src/input/mouse.rs b/core/editor/src/input/mouse.rs
@@ -14,7 +14,7 @@ impl ViewportPosition {
 		let y_diff = other.y as i64 - self.y as i64;
 		f64::sqrt((x_diff * x_diff + y_diff * y_diff) as f64)
 	}
-	pub fn to_dvec2(&self) -> DVec2 {
+	pub fn as_dvec2(&self) -> DVec2 {
 		DVec2::new(self.x as f64, self.y as f64)
 	}
 }
@@ -29,7 +29,7 @@ impl ScrollDelta {
 	pub fn new(x: i32, y: i32, z: i32) -> ScrollDelta {
 		ScrollDelta { x, y, z }
 	}
-	pub fn to_dvec2(&self) -> DVec2 {
+	pub fn as_dvec2(&self) -> DVec2 {
 		DVec2::new(self.x as f64, self.y as f64)
 	}
 	pub fn scroll_delta(&self) -> f64 {
diff --git a/core/editor/src/tool/tools/pen.rs b/core/editor/src/tool/tools/pen.rs
@@ -56,7 +56,7 @@ impl Fsm for PenToolFsmState {
 
 	fn transition(self, event: ToolMessage, document: &Document, tool_data: &DocumentToolData, data: &mut Self::ToolData, input: &InputPreprocessor, responses: &mut VecDeque<Message>) -> Self {
 		let transform = document.document.root.transform;
-		let pos = transform.inverse() * DAffine2::from_translation(input.mouse.position.to_dvec2());
+		let pos = transform.inverse() * DAffine2::from_translation(input.mouse.position.as_dvec2());
 
 		use PenMessage::*;
 		use PenToolFsmState::*;

Original file line number	Diff line number	Diff line change
`@@ -105,9 +105,7 @@ impl Folder {`
`105`	`105`	`pub fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {`
`106`	`106`	`let mut layers_non_empty_bounding_boxes = self.layers.iter().filter_map(\|layer\| layer.bounding_box(transform * layer.transform, layer.style)).peekable();`
`107`	`107`
`108`		`- if layers_non_empty_bounding_boxes.peek().is_none() {`
`109`		`- return None;`
`110`		`- }`
	`108`	`+ layers_non_empty_bounding_boxes.peek()?;`
`111`	`109`
`112`	`110`	`let mut x_min = f64::MAX;`
`113`	`111`	`let mut y_min = f64::MAX;`
`@@ -128,7 +126,7 @@ impl Folder {`
`128`	`126`	`y_max = bounding_box_max.y`
`129`	`127`	`}`
`130`	`128`	`}`
`131`		`- return Some([DVec2::new(x_min, y_min), DVec2::new(x_max, y_max)]);`
	`129`	`+ Some([DVec2::new(x_min, y_min), DVec2::new(x_max, y_max)])`
`132`	`130`	`}`
`133`	`131`	`}`
`134`	`132`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl Layer {`
`135`	`135`	`name: None,`
`136`	`136`	`data,`
`137`	`137`	`transform: glam::DAffine2::from_cols_array(&transform),`
`138`		`- style: style,`
	`138`	`+ style,`
`139`	`139`	`cache: String::new(),`
`140`	`140`	`cache_dirty: true,`
`141`	`141`	`}`
`@@ -171,7 +171,7 @@ impl Layer {`
`171`	`171`	`*svg += self.render();`
`172`	`172`	`}`
`173`	`173`
`174`		`- pub fn to_kurbo_path(&mut self) -> BezPath {`
	`174`	`+ pub fn to_kurbo_path(&self) -> BezPath {`
`175`	`175`	`self.data.to_kurbo_path(self.transform, self.style)`
`176`	`176`	`}`
`177`	`177`
`@@ -198,9 +198,8 @@ impl Layer {`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`pub fn render_as_folder(&mut self, svg: &mut String) {`
`201`		`- match &mut self.data {`
`202`		`- LayerDataTypes::Folder(f) => f.render(svg, self.transform, self.style),`
`203`		`- _ => {}`
	`201`	`+ if let LayerDataTypes::Folder(f) = &mut self.data {`
	`202`	`+ f.render(svg, self.transform, self.style)`
`204`	`203`	`}`
`205`	`204`	`}`
`206`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ impl LayerData {`
`108`	`108`	`let offset_transform = DAffine2::from_translation(offset);`
`109`	`109`	`let scale_transform = DAffine2::from_scale(DVec2::new(self.scale, self.scale));`
`110`	`110`	`let angle_transform = DAffine2::from_angle(self.snapped_angle());`
`111`		`- let translation_transform = DAffine2::from_translation(self.translation.into());`
	`111`	`+ let translation_transform = DAffine2::from_translation(self.translation);`
`112`	`112`	`scale_transform * offset_transform * angle_transform * scale_transform * translation_transform`
`113`	`113`	`}`
`114`	`114`	`pub fn calculate_transform(&self) -> DAffine2 {`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ impl ViewportPosition {`
`14`	`14`	`let y_diff = other.y as i64 - self.y as i64;`
`15`	`15`	`f64::sqrt((x_diff * x_diff + y_diff * y_diff) as f64)`
`16`	`16`	`}`
`17`		`- pub fn to_dvec2(&self) -> DVec2 {`
	`17`	`+ pub fn as_dvec2(&self) -> DVec2 {`
`18`	`18`	`DVec2::new(self.x as f64, self.y as f64)`
`19`	`19`	`}`
`20`	`20`	`}`
`@@ -29,7 +29,7 @@ impl ScrollDelta {`
`29`	`29`	`pub fn new(x: i32, y: i32, z: i32) -> ScrollDelta {`
`30`	`30`	`ScrollDelta { x, y, z }`
`31`	`31`	`}`
`32`		`- pub fn to_dvec2(&self) -> DVec2 {`
	`32`	`+ pub fn as_dvec2(&self) -> DVec2 {`
`33`	`33`	`DVec2::new(self.x as f64, self.y as f64)`
`34`	`34`	`}`
`35`	`35`	`pub fn scroll_delta(&self) -> f64 {`