Fix clippy warnings (#3085)

* Run clippy fix

* Clippy v2

* Make const item static

* Cargo fmt

Author: TrueDoctor

editor/src/dispatcher.rs

@@ -442,7 +442,7 @@ mod test {
 		assert_eq!(layers_before_copy.len(), 3);
 		assert_eq!(layers_after_copy.len(), 6);
 
-		println!("{:?} {:?}", layers_after_copy, layers_before_copy);
+		println!("{layers_after_copy:?} {layers_before_copy:?}");
 
 		assert_eq!(layers_after_copy[5], shape_id);
 	}

editor/src/messages/input_mapper/utility_types/input_keyboard.rs

@@ -479,7 +479,7 @@ impl<const LENGTH: usize> Iterator for BitVectorIter<'_, LENGTH> {
 impl<const LENGTH: usize> Display for BitVector<LENGTH> {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		for storage in self.0.iter().rev() {
-			write!(f, "{:0width$b}", storage, width = STORAGE_SIZE_BITS)?;
+			write!(f, "{storage:0STORAGE_SIZE_BITS$b}")?;
 		}
 
 		Ok(())

editor/src/messages/message.rs

@@ -70,13 +70,11 @@ mod test {
 	fn print_tree_node(tree: &DebugMessageTree, prefix: &str, is_last: bool, file: &mut std::fs::File) {
 		// Print the current node
 		let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() || tree.message_handler_fields().is_some() {
-			("├── ", format!("{}│   ", prefix))
+			("├── ", format!("{prefix}│   "))
+		} else if is_last {
+			("└── ", format!("{prefix}    "))
 		} else {
-			if is_last {
-				("└── ", format!("{}    ", prefix))
-			} else {
-				("├── ", format!("{}│   ", prefix))
-			}
+			("├── ", format!("{prefix}│   "))
 		};
 
 		if tree.path().is_empty() {
@@ -101,17 +99,17 @@ mod test {
 				let is_last_field = i == len - 1;
 				let branch = if is_last_field { "└── " } else { "├── " };
 
-				file.write_all(format!("{}{}{}\n", child_prefix, branch, field).as_bytes()).unwrap();
+				file.write_all(format!("{child_prefix}{branch}{field}\n").as_bytes()).unwrap();
 			}
 		}
 
 		// Print handler field if any
 		if let Some(data) = tree.message_handler_fields() {
 			let len = data.fields().len();
 			let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() {
-				("├── ", format!("{}│   ", prefix))
+				("├── ", format!("{prefix}│   "))
 			} else {
-				("└── ", format!("{}    ", prefix))
+				("└── ", format!("{prefix}    "))
 			};
 
 			const FRONTEND_MESSAGE_STR: &str = "FrontendMessage";

editor/src/messages/portfolio/document/graph_operation/transform_utils.rs

@@ -91,6 +91,32 @@ pub fn get_current_normalized_pivot(inputs: &[NodeInput]) -> DVec2 {
 	if let Some(&TaggedValue::DVec2(pivot)) = inputs[5].as_value() { pivot } else { DVec2::splat(0.5) }
 }
 
+/// Expand a bounds to avoid div zero errors
+fn clamp_bounds(bounds_min: DVec2, mut bounds_max: DVec2) -> [DVec2; 2] {
+	let bounds_size = bounds_max - bounds_min;
+	if bounds_size.x < 1e-10 {
+		bounds_max.x = bounds_min.x + 1.;
+	}
+	if bounds_size.y < 1e-10 {
+		bounds_max.y = bounds_min.y + 1.;
+	}
+	[bounds_min, bounds_max]
+}
+/// Returns corners of all subpaths
+fn subpath_bounds(subpaths: &[Subpath<PointId>]) -> [DVec2; 2] {
+	subpaths
+		.iter()
+		.filter_map(|subpath| subpath.bounding_box())
+		.reduce(|b1, b2| [b1[0].min(b2[0]), b1[1].max(b2[1])])
+		.unwrap_or_default()
+}
+
+/// Returns corners of all subpaths (but expanded to avoid division-by-zero errors)
+pub fn nonzero_subpath_bounds(subpaths: &[Subpath<PointId>]) -> [DVec2; 2] {
+	let [bounds_min, bounds_max] = subpath_bounds(subpaths);
+	clamp_bounds(bounds_min, bounds_max)
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -138,29 +164,3 @@ mod tests {
 		}
 	}
 }
-
-/// Expand a bounds to avoid div zero errors
-fn clamp_bounds(bounds_min: DVec2, mut bounds_max: DVec2) -> [DVec2; 2] {
-	let bounds_size = bounds_max - bounds_min;
-	if bounds_size.x < 1e-10 {
-		bounds_max.x = bounds_min.x + 1.;
-	}
-	if bounds_size.y < 1e-10 {
-		bounds_max.y = bounds_min.y + 1.;
-	}
-	[bounds_min, bounds_max]
-}
-/// Returns corners of all subpaths
-fn subpath_bounds(subpaths: &[Subpath<PointId>]) -> [DVec2; 2] {
-	subpaths
-		.iter()
-		.filter_map(|subpath| subpath.bounding_box())
-		.reduce(|b1, b2| [b1[0].min(b2[0]), b1[1].max(b2[1])])
-		.unwrap_or_default()
-}
-
-/// Returns corners of all subpaths (but expanded to avoid division-by-zero errors)
-pub fn nonzero_subpath_bounds(subpaths: &[Subpath<PointId>]) -> [DVec2; 2] {
-	let [bounds_min, bounds_max] = subpath_bounds(subpaths);
-	clamp_bounds(bounds_min, bounds_max)
-}

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -46,7 +46,7 @@ impl NodePropertiesContext<'_> {
 				return None;
 			};
 			widget_override_lambda(*node_id, index, self)
-				.map_err(|error| log::error!("Error in widget override lambda: {}", error))
+				.map_err(|error| log::error!("Error in widget override lambda: {error}"))
 				.ok()
 		} else {
 			None
@@ -1944,10 +1944,10 @@ fn static_input_properties() -> InputProperties {
 		"string".to_string(),
 		Box::new(|node_id, index, context| {
 			let Some(value) = context.network_interface.input_data(&node_id, index, "string_properties", context.selection_network_path) else {
-				return Err(format!("Could not get string properties for node {}", node_id));
+				return Err(format!("Could not get string properties for node {node_id}"));
 			};
 			let Some(string) = value.as_str() else {
-				return Err(format!("Could not downcast string properties for node {}", node_id));
+				return Err(format!("Could not downcast string properties for node {node_id}"));
 			};
 			Ok(node_properties::string_properties(string))
 		}),

editor/src/messages/portfolio/document/node_graph/document_node_definitions/document_node_derive.rs

@@ -60,7 +60,7 @@ pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec
 				document_node: DocumentNode {
 					inputs,
 					manual_composition: Some(input_type.clone()),
-					implementation: DocumentNodeImplementation::ProtoNode(id.clone().into()),
+					implementation: DocumentNodeImplementation::ProtoNode(id.clone()),
 					visible: true,
 					skip_deduplication: false,
 					..Default::default()

editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs

@@ -1516,7 +1516,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 				let mut nodes = Vec::new();
 				for node_id in &self.frontend_nodes {
 					let Some(node_bbox) = network_interface.node_bounding_box(node_id, breadcrumb_network_path) else {
-						log::error!("Could not get bbox for node: {:?}", node_id);
+						log::error!("Could not get bbox for node: {node_id:?}");
 						continue;
 					};
 
@@ -1721,7 +1721,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 			}
 			NodeGraphMessage::ToggleLocked { node_id } => {
 				let Some(node_metadata) = network_interface.document_network_metadata().persistent_metadata.node_metadata.get(&node_id) else {
-					log::error!("Cannot get node {:?} in NodeGraphMessage::ToggleLocked", node_id);
+					log::error!("Cannot get node {node_id:?} in NodeGraphMessage::ToggleLocked");
 					return;
 				};
 
@@ -2486,7 +2486,7 @@ impl NodeGraphMessageHandler {
 					data_type: frontend_data_type,
 					name: "Output 1".to_string(),
 					description: String::new(),
-					resolved_type: format!("{:?}", output_type),
+					resolved_type: format!("{output_type:?}"),
 					connected_to,
 				})
 			} else {
@@ -2518,7 +2518,7 @@ impl NodeGraphMessageHandler {
 					data_type,
 					name: output_name,
 					description: String::new(),
-					resolved_type: format!("{:?}", output_type),
+					resolved_type: format!("{output_type:?}"),
 					connected_to,
 				});
 			}

editor/src/messages/portfolio/document/overlays/utility_types_vello.rs

@@ -1156,7 +1156,7 @@ impl OverlayContextInternal {
 				let move_to = last_point != Some(start_id);
 				last_point = Some(end_id);
 
-				self.bezier_to_path(bezier, row.transform.clone(), move_to, &mut path);
+				self.bezier_to_path(bezier, *row.transform, move_to, &mut path);
 			}
 
 			// Render the path

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -73,10 +73,8 @@ impl NodeNetworkInterface {
 					fix_network(network);
 				}
 				if let DocumentNodeImplementation::ProtoNode(protonode) = &node.implementation {
-					if protonode.name.contains("PathModifyNode") {
-						if node.inputs.len() < 3 {
-							node.inputs.push(NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath));
-						}
+					if protonode.name.contains("PathModifyNode") && node.inputs.len() < 3 {
+						node.inputs.push(NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath));
 					}
 				}
 			}
@@ -821,7 +819,7 @@ impl NodeNetworkInterface {
 								data_type,
 								name,
 								description,
-								resolved_type: format!("{:?}", input_type),
+								resolved_type: format!("{input_type:?}"),
 								connected_to,
 							},
 							click_target,
@@ -1069,7 +1067,7 @@ impl NodeNetworkInterface {
 
 	pub fn reference(&self, node_id: &NodeId, network_path: &[NodeId]) -> Option<&Option<String>> {
 		let Some(node_metadata) = self.node_metadata(node_id, network_path) else {
-			log::error!("Could not get reference for node: {:?}", node_id);
+			log::error!("Could not get reference for node: {node_id:?}");
 			return None;
 		};
 		Some(&node_metadata.persistent_metadata.reference)
@@ -2522,15 +2520,15 @@ impl NodeNetworkInterface {
 			InputConnector::Node { node_id, input_index } => {
 				let input_metadata = self.transient_input_metadata(node_id, *input_index, network_path)?;
 				let TransientMetadata::Loaded(wire) = &input_metadata.wire else {
-					log::error!("Could not load wire for input: {:?}", input);
+					log::error!("Could not load wire for input: {input:?}");
 					return None;
 				};
 				wire.clone()
 			}
 			InputConnector::Export(export_index) => {
 				let network_metadata = self.network_metadata(network_path)?;
 				let Some(TransientMetadata::Loaded(wire)) = network_metadata.transient_metadata.wires.get(*export_index) else {
-					log::error!("Could not load wire for input: {:?}", input);
+					log::error!("Could not load wire for input: {input:?}");
 					return None;
 				};
 				wire.clone()
@@ -2701,12 +2699,12 @@ impl NodeNetworkInterface {
 			return None;
 		}
 		let Some(input_position) = self.get_input_center(&input, network_path) else {
-			log::error!("Could not get dom rect for wire end in root node: {:?}", input);
+			log::error!("Could not get dom rect for wire end in root node: {input:?}");
 			return None;
 		};
 		let upstream_output = OutputConnector::node(root_node.node_id, root_node.output_index);
 		let Some(output_position) = self.get_output_center(&upstream_output, network_path) else {
-			log::error!("Could not get dom rect for wire start in root node: {:?}", upstream_output);
+			log::error!("Could not get dom rect for wire start in root node: {upstream_output:?}");
 			return None;
 		};
 		let vertical_end = input.node_id().is_some_and(|node_id| self.is_layer(&node_id, network_path) && input.input_index() == 0);
@@ -2733,15 +2731,15 @@ impl NodeNetworkInterface {
 	/// Returns the vector subpath and a boolean of whether the wire should be thick.
 	pub fn vector_wire_from_input(&mut self, input: &InputConnector, wire_style: GraphWireStyle, network_path: &[NodeId]) -> Option<(BezPath, bool)> {
 		let Some(input_position) = self.get_input_center(input, network_path) else {
-			log::error!("Could not get dom rect for wire end: {:?}", input);
+			log::error!("Could not get dom rect for wire end: {input:?}");
 			return None;
 		};
 		// An upstream output could not be found, so the wire does not exist, but it should still be loaded as as empty vector
 		let Some(upstream_output) = self.upstream_output_connector(input, network_path) else {
 			return Some((BezPath::new(), false));
 		};
 		let Some(output_position) = self.get_output_center(&upstream_output, network_path) else {
-			log::error!("Could not get dom rect for wire start: {:?}", upstream_output);
+			log::error!("Could not get dom rect for wire start: {upstream_output:?}");
 			return None;
 		};
 		let vertical_end = input.node_id().is_some_and(|node_id| self.is_layer(&node_id, network_path) && input.input_index() == 0);
@@ -3357,7 +3355,7 @@ impl NodeNetworkInterface {
 		self.selected_nodes()
 			.0
 			.iter()
-			.filter(|node| self.is_layer(&node, &[]))
+			.filter(|node| self.is_layer(node, &[]))
 			.filter_map(|layer| self.document_metadata.bounding_box_viewport(LayerNodeIdentifier::new(*layer, self)))
 			.reduce(Quad::combine_bounds)
 	}
@@ -3366,7 +3364,7 @@ impl NodeNetworkInterface {
 		self.selected_nodes()
 			.0
 			.iter()
-			.filter(|node| self.is_layer(&node, &[]) && !self.is_locked(&node, &[]))
+			.filter(|node| self.is_layer(node, &[]) && !self.is_locked(node, &[]))
 			.filter_map(|layer| self.document_metadata.bounding_box_viewport(LayerNodeIdentifier::new(*layer, self)))
 			.reduce(Quad::combine_bounds)
 	}
@@ -4138,7 +4136,7 @@ impl NodeNetworkInterface {
 		if let DocumentNodeImplementation::Network(network) = &node.implementation {
 			let number_of_exports = network.exports.len();
 			let Some(metadata) = self.node_metadata_mut(node_id, network_path) else {
-				log::error!("Could not get metadata for node: {:?}", node_id);
+				log::error!("Could not get metadata for node: {node_id:?}");
 				return;
 			};
 			metadata.persistent_metadata.output_names.resize(number_of_exports, "".to_string());

editor/src/messages/portfolio/document_migration.rs

@@ -1083,8 +1083,8 @@ mod tests {
 			*hashmap.entry(node.node.clone()).or_default() += 1;
 		});
 		let duplicates = hashmap.iter().filter(|(_, count)| **count > 1).map(|(node, _)| &node.name).collect::<Vec<_>>();
-		if duplicates.len() > 0 {
-			panic!("Duplicate entries in `NODE_REPLACEMENTS`: {:?}", duplicates);
+		if !duplicates.is_empty() {
+			panic!("Duplicate entries in `NODE_REPLACEMENTS`: {duplicates:?}");
 		}
 	}
 }