Clean up and suppress Clippy warnings (#1402)

* fix: clear and suppress clippy warnings

* Simplification

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

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

@@ -738,11 +738,7 @@ pub fn boolean_properties(document_node: &DocumentNode, node_id: NodeId, _contex
 }
 
 pub fn color_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let operand = |name: &str, index| {
-		let color = color_widget(document_node, node_id, index, name, ColorInput::default(), true);
-
-		color
-	};
+	let operand = |name: &str, index| color_widget(document_node, node_id, index, name, ColorInput::default(), true);
 	vec![operand("Color", 0)]
 }
 
@@ -790,20 +786,12 @@ pub fn mask_properties(document_node: &DocumentNode, node_id: NodeId, _context:
 }
 
 pub fn blend_mode_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let operand = |name: &str, index| {
-		let blend_mode = blend_mode(document_node, node_id, index, name, true);
-
-		blend_mode
-	};
+	let operand = |name: &str, index| blend_mode(document_node, node_id, index, name, true);
 	vec![operand("Blend Mode", 0)]
 }
 
 pub fn color_channel_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let operand = |name: &str, index| {
-		let color_channel = color_channel(document_node, node_id, index, name, true);
-
-		color_channel
-	};
+	let operand = |name: &str, index| color_channel(document_node, node_id, index, name, true);
 	vec![operand("Channel", 0)]
 }
 

editor/src/messages/tool/tool_messages/select_tool.rs

@@ -778,7 +778,7 @@ impl Fsm for SelectToolFsmState {
 						let intersection = document.document_legacy.intersects_quad_root(quad, render_data);
 
 						if let Some(path) = intersection.last() {
-							let replacement_selected_layers: Vec<_> = document.selected_layers().filter(|&layer| !path.starts_with(&layer)).map(|path| path.to_vec()).collect();
+							let replacement_selected_layers: Vec<_> = document.selected_layers().filter(|&layer| !path.starts_with(layer)).map(|path| path.to_vec()).collect();
 
 							tool_data.layers_dragging.clear();
 							tool_data.layers_dragging.append(replacement_selected_layers.clone().as_mut());
@@ -1086,7 +1086,6 @@ fn drag_shallowest_manipulation(
 
 		tool_data.layers_dragging.append(selected.clone().as_mut());
 		responses.add(DocumentMessage::AddSelectedLayers { additional_layers: selected.clone() });
-		return;
 	}
 	// Accel click selects the deepest layer directly
 	else if input.keyboard.get(select_deepest as usize) {
@@ -1099,7 +1098,7 @@ fn drag_shallowest_manipulation(
 	// Check whether a layer is selected for next selection calculations
 	else if !selected_layers_collected.is_empty() {
 		// Check if the intersected layer path is already selected
-		let already_selected_parent = previous_parents.contains(&&[incoming_parent].as_slice());
+		let already_selected_parent = previous_parents.contains(&[incoming_parent].as_slice());
 		let mut search = vec![];
 		let mut recursive_found = false;
 
@@ -1108,10 +1107,10 @@ fn drag_shallowest_manipulation(
 			// Use the combined layers of currently selected and incoming and get shallowest common folder
 			let mut combined_layers = selected_layers_collected.to_vec();
 			if !combined_layers.contains(&incoming_layer_path_vector.as_slice()) && !incoming_layer_path_vector.is_empty() {
-				combined_layers.push(&incoming_layer_path_vector);
+				combined_layers.push(incoming_layer_path_vector);
 			}
 			// Shared shallowest common folder of the combined layers
-			let shallowest_common_folder = document.document_legacy.shallowest_common_folder(combined_layers.to_vec().into_iter()).unwrap_or_default().to_vec();
+			let shallowest_common_folder = document.document_legacy.shallowest_common_folder(combined_layers.iter().copied()).unwrap_or_default().to_vec();
 			let mut selected_layer_path_parent = shallowest_common_folder.to_vec();
 
 			// Determine if the incoming layer path is already selected
@@ -1120,15 +1119,15 @@ fn drag_shallowest_manipulation(
 				.any(|layer| &incoming_layer_path_vector[..layer.len()] == layer);
 
 			// Recursively search through each children of the selected layer path parent, if not found move up a layer
-			while selected_layer_path_parent.len() > 0 && !recursive_found {
+			while !selected_layer_path_parent.is_empty() && !recursive_found {
 				let selected_children_layer_paths = document.document_legacy.folder_children_paths(&selected_layer_path_parent);
 				for child in selected_children_layer_paths {
 					if child == *incoming_layer_path_vector {
 						search = child;
 						recursive_found = true;
 						break;
-					} else if document.document_legacy.is_folder(child.to_vec()) {
-						recursive_found = recursive_search(document, &child, &incoming_layer_path_vector);
+					} else if document.document_legacy.is_folder(&child) {
+						recursive_found = recursive_search(document, &child, incoming_layer_path_vector);
 						if recursive_found {
 							search = child;
 							break;
@@ -1169,8 +1168,8 @@ fn drag_shallowest_manipulation(
 				}
 			} else if selected_layers_count > 1 {
 				let direct_child = incoming_layer_path_vector
-					.to_vec()
-					.into_iter()
+					.iter()
+					.copied()
 					.filter(|path| !shallowest_common_folder.contains(path))
 					.take(1)
 					.collect::<Vec<_>>();
@@ -1193,9 +1192,9 @@ fn drag_shallowest_manipulation(
 					.into_iter()
 					.filter(|layer| {
 						if !search.is_empty() {
-							layer.len() >= search.len() && &layer[..search.len()] != search
+							layer.len() >= search.len() && layer[..search.len()] != search
 						} else {
-							layer.len() >= direct_child.len() && &layer[..direct_child.len()] != direct_child
+							layer.len() >= direct_child.len() && layer[..direct_child.len()] != direct_child
 						}
 					})
 					.for_each(|layer| replacement_selected_layers.push(layer.to_vec()));
@@ -1235,21 +1234,19 @@ fn drag_shallowest_manipulation(
 					}
 				}
 				// Normal Click: Selecting new layers
-				else {
-					if !already_selected {
-						if !search.is_empty() {
-							tool_data.layers_dragging.clear();
-							tool_data.layers_dragging = vec![search.to_vec()];
-							responses.add(DocumentMessage::SetSelectedLayers {
-								replacement_selected_layers: vec![search],
-							});
-						} else {
-							tool_data.layers_dragging.clear();
-							tool_data.layers_dragging = vec![direct_child.to_vec()];
-							responses.add(DocumentMessage::SetSelectedLayers {
-								replacement_selected_layers: vec![direct_child],
-							});
-						}
+				else if !already_selected {
+					if !search.is_empty() {
+						tool_data.layers_dragging.clear();
+						tool_data.layers_dragging = vec![search.to_vec()];
+						responses.add(DocumentMessage::SetSelectedLayers {
+							replacement_selected_layers: vec![search],
+						});
+					} else {
+						tool_data.layers_dragging.clear();
+						tool_data.layers_dragging = vec![direct_child.to_vec()];
+						responses.add(DocumentMessage::SetSelectedLayers {
+							replacement_selected_layers: vec![direct_child],
+						});
 					}
 				}
 			}
@@ -1302,7 +1299,7 @@ fn edit_layer_shallowest_manipulation(document: &DocumentMessageHandler, interse
 	let previous_parents: Vec<_> = (0..selected_layers_collected.len())
 		.map(|i| &selected_layers_collected.get(i).unwrap_or(&empty_vector.as_slice())[..1])
 		.collect();
-	let incoming_parent_selected = previous_parents.contains(&&[incoming_parent].as_slice());
+	let incoming_parent_selected = previous_parents.contains(&[incoming_parent].as_slice());
 
 	if incoming_parent_selected {
 		// Permutations of intersected layer
@@ -1351,15 +1348,12 @@ fn edit_layer_deepest_manipulation(intersect: &Layer, responses: &mut VecDeque<M
 	}
 }
 
+#[allow(clippy::if_same_then_else)]
 fn recursive_search(document: &DocumentMessageHandler, layer_path: &[u64], incoming_layer_path_vector: &Vec<u64>) -> bool {
 	let layer_paths = document.document_legacy.folder_children_paths(layer_path);
 	for path in layer_paths {
-		if path == *incoming_layer_path_vector {
+		if path == *incoming_layer_path_vector || (document.document_legacy.is_folder(&path) && recursive_search(document, &path, incoming_layer_path_vector)) {
 			return true;
-		} else if document.document_legacy.is_folder(path.to_vec()) {
-			if recursive_search(document, &path, incoming_layer_path_vector) {
-				return true;
-			}
 		}
 	}
 	false

node-graph/gcore/src/raster/adjustments.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_arguments)]
+
 use super::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
 use super::{Channel, Color, Node};
 

node-graph/gcore/src/text.rs

@@ -17,5 +17,5 @@ pub struct TextGenerator<Text, FontName, Size> {
 #[node_fn(TextGenerator)]
 fn generate_text<'a: 'input, T>(editor: EditorApi<'a, T>, text: String, font_name: Font, font_size: f64) -> crate::vector::VectorData {
 	let buzz_face = editor.font_cache.get(&font_name).map(|data| load_face(data));
-	crate::vector::VectorData::from_subpaths(to_path(&text, buzz_face, font_size as f64, None))
+	crate::vector::VectorData::from_subpaths(to_path(&text, buzz_face, font_size, None))
 }

node-graph/interpreted-executor/src/node_registry.rs

@@ -463,9 +463,9 @@ fn node_registry() -> HashMap<NodeIdentifier, HashMap<NodeIOTypes, NodeConstruct
 					use graphene_core::raster::brightness_contrast::*;
 
 					let brightness: DowncastBothNode<(), f32> = DowncastBothNode::new(args[0].clone());
-					let brightness = ClonedNode::new(brightness.eval(()).await as f32);
+					let brightness = ClonedNode::new(brightness.eval(()).await);
 					let contrast: DowncastBothNode<(), f32> = DowncastBothNode::new(args[1].clone());
-					let contrast = ClonedNode::new(contrast.eval(()).await as f32);
+					let contrast = ClonedNode::new(contrast.eval(()).await);
 					let use_legacy: DowncastBothNode<(), bool> = DowncastBothNode::new(args[2].clone());
 
 					if use_legacy.eval(()).await {

proc-macros/src/discriminant.rs

@@ -47,7 +47,7 @@ pub fn derive_discriminant_impl(input_item: TokenStream) -> syn::Result<TokenStr
 				}
 			}
 		}
-		var.attrs = var.attrs.iter().enumerate().filter(|(i, _)| retain.contains(&i)).map(|(_, x)| x.clone()).collect();
+		var.attrs = var.attrs.iter().enumerate().filter(|(i, _)| retain.contains(i)).map(|(_, x)| x.clone()).collect();
 	}
 
 	let attrs = input