Apply clippy lints

TrueDoctor · TrueDoctor · commit 5b87543e9511 · 2025-03-08T14:23:51.000+01:00
diff --git a/editor/src/messages/portfolio/document/document_message_handler.rs b/editor/src/messages/portfolio/document/document_message_handler.rs
@@ -1655,7 +1655,7 @@ impl DocumentMessageHandler {
 				path.pop();
 			}
 		}
-		structure_section.push(space | 1 << 63);
+		structure_section.push(space | (1 << 63));
 	}
 
 	/// Serializes the layer structure into a condensed 1D structure.
diff --git a/editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs b/editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs
@@ -2114,16 +2114,11 @@ impl NodeGraphMessageHandler {
 						wire_end: InputConnector::Export(i),
 						dashed,
 					});
-				} else {
-					match *export {
-						NodeInput::Network { import_index, .. } => wires.push(FrontendNodeWire {
-							wire_start: OutputConnector::Import(import_index),
-							wire_end: InputConnector::Export(i),
-							dashed,
-						}),
-						_ => {}
-					}
-				}
+				} else if let NodeInput::Network { import_index, .. } = *export { wires.push(FrontendNodeWire {
+    							wire_start: OutputConnector::Import(import_index),
+    							wire_end: InputConnector::Export(i),
+    							dashed,
+    						}) }
 			}
 		}
 		wires
diff --git a/editor/src/messages/portfolio/document/node_graph/node_properties.rs b/editor/src/messages/portfolio/document/node_graph/node_properties.rs
@@ -2226,7 +2226,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 		&document_node.inputs[backup_color_index].as_value(),
 		&document_node.inputs[backup_gradient_index].as_value(),
 	) {
-		(&Some(&TaggedValue::Fill(ref fill)), &Some(&TaggedValue::OptionalColor(backup_color)), &Some(&TaggedValue::Gradient(ref backup_gradient))) => (fill, backup_color, backup_gradient),
+		(&Some(TaggedValue::Fill(fill)), &Some(&TaggedValue::OptionalColor(backup_color)), &Some(TaggedValue::Gradient(backup_gradient))) => (fill, backup_color, backup_gradient),
 		_ => {
 			return vec![LayoutGroup::Row { widgets: widgets_first_row }];
 		}
diff --git a/editor/src/messages/portfolio/document/utility_types/network_interface.rs b/editor/src/messages/portfolio/document/utility_types/network_interface.rs
@@ -366,7 +366,7 @@ impl NodeNetworkInterface {
 
 					// If a chain node does not have a selected downstream layer, then set the position to absolute
 					let downstream_layer = self.downstream_layer(node_id, network_path);
-					if downstream_layer.map_or(true, |downstream_layer| new_ids.keys().all(|key| *key != downstream_layer.to_node())) {
+					if downstream_layer.is_none_or(|downstream_layer| new_ids.keys().all(|key| *key != downstream_layer.to_node())) {
 						let Some(position) = self.position(node_id, network_path) else {
 							log::error!("Could not get position in create_node_template");
 							return None;
@@ -4688,16 +4688,13 @@ impl NodeNetworkInterface {
 				node_metadata.position = NodePosition::Absolute(position);
 				self.transaction_modified();
 			}
-			_ => match &mut node_metadata.persistent_metadata.node_type_metadata {
-				NodeTypePersistentMetadata::Layer(layer_metadata) => {
-					if layer_metadata.position == LayerPosition::Absolute(position) {
-						return;
-					}
-					layer_metadata.position = LayerPosition::Absolute(position);
-					self.transaction_modified();
-				}
-				_ => {}
-			},
+			_ => if let NodeTypePersistentMetadata::Layer(layer_metadata) = &mut node_metadata.persistent_metadata.node_type_metadata {
+   					if layer_metadata.position == LayerPosition::Absolute(position) {
+   						return;
+   					}
+   					layer_metadata.position = LayerPosition::Absolute(position);
+   					self.transaction_modified();
+   				},
 		}
 	}
 
@@ -5334,21 +5331,18 @@ impl NodeNetworkInterface {
 				self.unload_upstream_node_click_targets(vec![*node_id], network_path);
 			}
 			_ => {
-				match &mut node_metadata.persistent_metadata.node_type_metadata {
-					NodeTypePersistentMetadata::Node(node_metadata) => {
-						if let NodePosition::Absolute(node_metadata) = &mut node_metadata.position {
-							*node_metadata += shift;
-							self.transaction_modified();
-							// Unload click targets for all upstream nodes, since they may have been derived from the node that was shifted
-							self.unload_upstream_node_click_targets(vec![*node_id], network_path);
-							self.try_set_node_to_chain(node_id, network_path);
-						} else if let NodePosition::Chain = node_metadata.position {
-							self.set_upstream_chain_to_absolute(node_id, network_path);
-							self.shift_node(node_id, shift, network_path);
-						}
-					}
-					_ => {}
-				}
+				if let NodeTypePersistentMetadata::Node(node_metadata) = &mut node_metadata.persistent_metadata.node_type_metadata {
+    						if let NodePosition::Absolute(node_metadata) = &mut node_metadata.position {
+    							*node_metadata += shift;
+    							self.transaction_modified();
+    							// Unload click targets for all upstream nodes, since they may have been derived from the node that was shifted
+    							self.unload_upstream_node_click_targets(vec![*node_id], network_path);
+    							self.try_set_node_to_chain(node_id, network_path);
+    						} else if let NodePosition::Chain = node_metadata.position {
+    							self.set_upstream_chain_to_absolute(node_id, network_path);
+    							self.shift_node(node_id, shift, network_path);
+    						}
+    					}
 			}
 		}
 		// Unload click targets for all upstream nodes, since they may have been derived from the node that was shifted
diff --git a/editor/src/messages/tool/common_functionality/shape_editor.rs b/editor/src/messages/tool/common_functionality/shape_editor.rs
@@ -1075,15 +1075,10 @@ impl ShapeState {
 							responses.add(GraphOperationMessage::Vector { layer, modification_type });
 						}
 					}
-				} else {
-					match point.get_handle_pair(&vector_data) {
-						Some(handles) => {
-							let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };
-							responses.add(GraphOperationMessage::Vector { layer, modification_type });
-						}
-						_ => {}
-					}
-				}
+				} else if let Some(handles) = point.get_handle_pair(&vector_data) {
+    							let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };
+    							responses.add(GraphOperationMessage::Vector { layer, modification_type });
+    						}
 			}
 		}
 	}
diff --git a/editor/src/messages/tool/common_functionality/snapping/alignment_snapper.rs b/editor/src/messages/tool/common_functionality/snapping/alignment_snapper.rs
@@ -89,7 +89,7 @@ impl AlignmentSnapper {
 			if let Some(point_on_x) = point_on_x {
 				let distance_to_snapped = point.document_point.distance(point_on_x);
 				let distance_to_align_target = point_on_x.distance(target_position);
-				if distance_to_snapped < tolerance && snap_x.as_ref().map_or(true, |point| distance_to_align_target < point.distance_to_align_target) {
+				if distance_to_snapped < tolerance && snap_x.as_ref().is_none_or(|point| distance_to_align_target < point.distance_to_align_target) {
 					snap_x = Some(SnappedPoint {
 						snapped_point_document: point_on_x,
 						source: point.source, // TODO(0Hypercube): map source
@@ -108,7 +108,7 @@ impl AlignmentSnapper {
 			if let Some(point_on_y) = point_on_y {
 				let distance_to_snapped = point.document_point.distance(point_on_y);
 				let distance_to_align_target = point_on_y.distance(target_position);
-				if distance_to_snapped < tolerance && snap_y.as_ref().map_or(true, |point| distance_to_align_target < point.distance_to_align_target) {
+				if distance_to_snapped < tolerance && snap_y.as_ref().is_none_or(|point| distance_to_align_target < point.distance_to_align_target) {
 					snap_y = Some(SnappedPoint {
 						snapped_point_document: point_on_y,
 						source: point.source, // TODO(0Hypercube): map source
diff --git a/editor/src/messages/tool/tool_messages/freehand_tool.rs b/editor/src/messages/tool/tool_messages/freehand_tool.rs
@@ -311,7 +311,7 @@ impl Fsm for FreehandToolFsmState {
 }
 
 fn extend_path_with_next_segment(tool_data: &mut FreehandToolData, position: DVec2, extend: bool, responses: &mut VecDeque<Message>) {
-	if !tool_data.end_point.map_or(true, |(last_pos, _)| position != last_pos) || !position.is_finite() {
+	if !tool_data.end_point.is_none_or(|(last_pos, _)| position != last_pos) || !position.is_finite() {
 		return;
 	}
 
diff --git a/editor/src/messages/tool/tool_messages/spline_tool.rs b/editor/src/messages/tool/tool_messages/spline_tool.rs
@@ -364,7 +364,7 @@ impl Fsm for SplineToolFsmState {
 					return SplineToolFsmState::Ready;
 				};
 				tool_data.next_point = tool_data.snapped_point(document, input).snapped_point_document;
-				if tool_data.points.last().map_or(true, |last_pos| last_pos.1.distance(tool_data.next_point) > DRAG_THRESHOLD) {
+				if tool_data.points.last().is_none_or(|last_pos| last_pos.1.distance(tool_data.next_point) > DRAG_THRESHOLD) {
 					let preview_point = tool_data.preview_point;
 					extend_spline(tool_data, false, responses);
 					tool_data.preview_point = preview_point;
diff --git a/editor/src/node_graph_executor.rs b/editor/src/node_graph_executor.rs
@@ -299,12 +299,9 @@ impl NodeRuntime {
 								Some(record) => {
 									self.vector_modify.insert(parent_network_node_id, record.output.one_instance().instance.clone());
 								}
-								_ => match introspected_data.downcast_ref::<IORecord<(), VectorDataTable>>() {
-									Some(record) => {
-										self.vector_modify.insert(parent_network_node_id, record.output.one_instance().instance.clone());
-									}
-									_ => {}
-								},
+								_ => if let Some(record) = introspected_data.downcast_ref::<IORecord<(), VectorDataTable>>() {
+        										self.vector_modify.insert(parent_network_node_id, record.output.one_instance().instance.clone());
+        									},
 							},
 						},
 					},
diff --git a/libraries/bezier-rs/src/subpath/solvers.rs b/libraries/bezier-rs/src/subpath/solvers.rs
@@ -954,19 +954,19 @@ mod tests {
 
 		let curve = Bezier::from_quadratic_dvec2(DVec2::new(189., 289.), DVec2::new(9., 286.), DVec2::new(45., 410.));
 		let curve_intersecting = Subpath::<EmptyId>::from_bezier(&curve);
-		assert_eq!(curve_intersecting.is_inside_subpath(&boundary_polygon, None, None), false);
+		assert!(!curve_intersecting.is_inside_subpath(&boundary_polygon, None, None));
 
 		let curve = Bezier::from_quadratic_dvec2(DVec2::new(115., 37.), DVec2::new(51.4, 91.8), DVec2::new(76.5, 242.));
 		let curve_outside = Subpath::<EmptyId>::from_bezier(&curve);
-		assert_eq!(curve_outside.is_inside_subpath(&boundary_polygon, None, None), false);
+		assert!(!curve_outside.is_inside_subpath(&boundary_polygon, None, None));
 
 		let curve = Bezier::from_cubic_dvec2(DVec2::new(210.1, 133.5), DVec2::new(150.2, 436.9), DVec2::new(436., 285.), DVec2::new(247.6, 240.7));
 		let curve_inside = Subpath::<EmptyId>::from_bezier(&curve);
-		assert_eq!(curve_inside.is_inside_subpath(&boundary_polygon, None, None), true);
+		assert!(curve_inside.is_inside_subpath(&boundary_polygon, None, None));
 
 		let line = Bezier::from_linear_dvec2(DVec2::new(101., 101.5), DVec2::new(150.2, 499.));
 		let line_inside = Subpath::<EmptyId>::from_bezier(&line);
-		assert_eq!(line_inside.is_inside_subpath(&boundary_polygon, None, None), true);
+		assert!(line_inside.is_inside_subpath(&boundary_polygon, None, None));
 	}
 
 	#[test]
diff --git a/libraries/bezier-rs/src/subpath/structs.rs b/libraries/bezier-rs/src/subpath/structs.rs
@@ -113,7 +113,7 @@ impl<PointId: crate::Identifier> ManipulatorGroup<PointId> {
 
 	/// Are all handles at finite positions
 	pub fn is_finite(&self) -> bool {
-		self.anchor.is_finite() && self.in_handle.map_or(true, |handle| handle.is_finite()) && self.out_handle.map_or(true, |handle| handle.is_finite())
+		self.anchor.is_finite() && self.in_handle.is_none_or(|handle| handle.is_finite()) && self.out_handle.is_none_or(|handle| handle.is_finite())
 	}
 
 	/// Reverse directions of handles
diff --git a/libraries/path-bool/src/path.rs b/libraries/path-bool/src/path.rs
@@ -107,7 +107,7 @@ where
 			let start = seg.start();
 			let mut commands = Vec::new();
 
-			if last_point.map_or(true, |lp| !start.abs_diff_eq(lp, eps)) {
+			if last_point.is_none_or(|lp| !start.abs_diff_eq(lp, eps)) {
 				if last_point.is_some() {
 					commands.push(PathCommand::Absolute(AbsolutePathCommand::Z));
 				}
diff --git a/node-graph/gcore/src/vector/vector_data/modification.rs b/node-graph/gcore/src/vector/vector_data/modification.rs
@@ -132,7 +132,7 @@ impl SegmentModification {
 			let start = self.handle_primary.get(&id).copied().map(|handle| handle.map(|handle| handle + start));
 			let end = self.handle_end.get(&id).copied().map(|handle| handle.map(|handle| handle + end));
 
-			if !start.unwrap_or_default().map_or(true, |start| start.is_finite()) || !end.unwrap_or_default().map_or(true, |end| end.is_finite()) {
+			if !start.unwrap_or_default().is_none_or(|start| start.is_finite()) || !end.unwrap_or_default().is_none_or(|end| end.is_finite()) {
 				warn!("Invalid handles when applying a segment modification");
 				continue;
 			}

Original file line number	Diff line number	Diff line change
`@@ -1655,7 +1655,7 @@ impl DocumentMessageHandler {`
`1655`	`1655`	`path.pop();`
`1656`	`1656`	`}`
`1657`	`1657`	`}`
`1658`		`- structure_section.push(space \| 1 << 63);`
	`1658`	`+ structure_section.push(space \| (1 << 63));`
`1659`	`1659`	`}`
`1660`	`1660`
`1661`	`1661`	`/// Serializes the layer structure into a condensed 1D structure.`
Original file line number	Diff line number	Diff line change
`@@ -2226,7 +2226,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte`
`2226`	`2226`	`&document_node.inputs[backup_color_index].as_value(),`
`2227`	`2227`	`&document_node.inputs[backup_gradient_index].as_value(),`
`2228`	`2228`	`) {`
`2229`		`- (&Some(&TaggedValue::Fill(ref fill)), &Some(&TaggedValue::OptionalColor(backup_color)), &Some(&TaggedValue::Gradient(ref backup_gradient))) => (fill, backup_color, backup_gradient),`
	`2229`	`+ (&Some(TaggedValue::Fill(fill)), &Some(&TaggedValue::OptionalColor(backup_color)), &Some(TaggedValue::Gradient(backup_gradient))) => (fill, backup_color, backup_gradient),`
`2230`	`2230`	`_ => {`
`2231`	`2231`	`return vec![LayoutGroup::Row { widgets: widgets_first_row }];`
`2232`	`2232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1075,15 +1075,10 @@ impl ShapeState {`
`1075`	`1075`	`responses.add(GraphOperationMessage::Vector { layer, modification_type });`
`1076`	`1076`	`}`
`1077`	`1077`	`}`
`1078`		`- } else {`
`1079`		`- match point.get_handle_pair(&vector_data) {`
`1080`		`- Some(handles) => {`
`1081`		`- let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };`
`1082`		`- responses.add(GraphOperationMessage::Vector { layer, modification_type });`
`1083`		`- }`
`1084`		`- _ => {}`
`1085`		`- }`
`1086`		`- }`
	`1078`	`+ } else if let Some(handles) = point.get_handle_pair(&vector_data) {`
	`1079`	`+ let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };`
	`1080`	`+ responses.add(GraphOperationMessage::Vector { layer, modification_type });`
	`1081`	`+ }`
`1087`	`1082`	`}`
`1088`	`1083`	`}`
`1089`	`1084`	`}`
Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ impl Fsm for FreehandToolFsmState {`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`fn extend_path_with_next_segment(tool_data: &mut FreehandToolData, position: DVec2, extend: bool, responses: &mut VecDeque<Message>) {`
`314`		`- if !tool_data.end_point.map_or(true, \|(last_pos, _)\| position != last_pos) \|\| !position.is_finite() {`
	`314`	`+ if !tool_data.end_point.is_none_or(\|(last_pos, _)\| position != last_pos) \|\| !position.is_finite() {`
`315`	`315`	`return;`
`316`	`316`	`}`
`317`	`317`