Clean up code by using Iterator::collect() when constructing instance tables

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

@@ -6804,13 +6804,6 @@ impl From<DocumentNodePersistentMetadataPropertiesRow> for DocumentNodePersisten
 	}
 }
 
-#[derive(serde::Serialize, serde::Deserialize)]
-enum NodePersistentMetadataVersions {
-	DocumentNodePersistentMetadataPropertiesRow(DocumentNodePersistentMetadataPropertiesRow),
-	NodePersistentMetadataInputNames(DocumentNodePersistentMetadataInputNames),
-	NodePersistentMetadata(DocumentNodePersistentMetadata),
-}
-
 fn deserialize_node_persistent_metadata<'de, D>(deserializer: D) -> Result<DocumentNodePersistentMetadata, D::Error>
 where
 	D: serde::Deserializer<'de>,

editor/src/messages/tool/common_functionality/shape_editor.rs

@@ -1000,7 +1000,7 @@ impl ShapeState {
 		} else {
 			// Push both in and out handles into the correct position
 			for ((handle, sign), other_anchor) in handles.iter().zip([1., -1.]).zip(&anchor_positions) {
-				let Some(anchor_vector) = other_anchor.map(|position| (position - anchor_position)) else {
+				let Some(anchor_vector) = other_anchor.map(|position| position - anchor_position) else {
 					continue;
 				};
 

libraries/bezier-rs/src/poisson_disk.rs

@@ -169,7 +169,7 @@ where
 	A::Item: Clone,
 	B::Item: Clone,
 {
-	a.flat_map(move |i| (b.clone().map(move |j| (i.clone(), j))))
+	a.flat_map(move |i| b.clone().map(move |j| (i.clone(), j)))
 }
 
 /// A square (represented by its top left corner position and width/height of `square_size`) that is currently a candidate for targetting by the dart throwing process.

libraries/path-bool/src/path_boolean.rs

@@ -1086,7 +1086,7 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 		let outer_face_key = if count != 1 {
 			#[cfg(feature = "logging")]
 			eprintln!("Found multiple outer faces: {areas:?}, falling back to area calculation");
-			let (key, _) = *areas.iter().max_by_key(|(_, area)| ((area.abs() * 1000.) as u64)).unwrap();
+			let (key, _) = *areas.iter().max_by_key(|(_, area)| (area.abs() * 1000.) as u64).unwrap();
 			*key
 		} else {
 			*windings

node-graph/gcore/src/instances.rs

@@ -27,6 +27,24 @@ impl<T> Instances<T> {
 		}
 	}
 
+	pub fn new_instance(instance: Instance<T>) -> Self {
+		Self {
+			instance: vec![instance.instance],
+			transform: vec![instance.transform],
+			alpha_blending: vec![instance.alpha_blending],
+			source_node_id: vec![instance.source_node_id],
+		}
+	}
+
+	pub fn with_capacity(capacity: usize) -> Self {
+		Self {
+			instance: Vec::with_capacity(capacity),
+			transform: Vec::with_capacity(capacity),
+			alpha_blending: Vec::with_capacity(capacity),
+			source_node_id: Vec::with_capacity(capacity),
+		}
+	}
+
 	pub fn push(&mut self, instance: Instance<T>) {
 		self.instance.push(instance.instance);
 		self.transform.push(instance.transform);
@@ -161,6 +179,18 @@ unsafe impl<T: StaticType + 'static> StaticType for Instances<T> {
 	type Static = Instances<T>;
 }
 
+impl<T> FromIterator<Instance<T>> for Instances<T> {
+	fn from_iter<I: IntoIterator<Item = Instance<T>>>(iter: I) -> Self {
+		let iter = iter.into_iter();
+		let (lower, _) = iter.size_hint();
+		let mut instances = Self::with_capacity(lower);
+		for instance in iter {
+			instances.push(instance);
+		}
+		instances
+	}
+}
+
 fn one_daffine2_default() -> Vec<DAffine2> {
 	vec![DAffine2::IDENTITY]
 }

node-graph/gcore/src/vector/algorithms/poisson_disk.rs

@@ -182,7 +182,7 @@ where
 	A::Item: Clone,
 	B::Item: Clone,
 {
-	a.flat_map(move |i| (b.clone().map(move |j| (i.clone(), j))))
+	a.flat_map(move |i| b.clone().map(move |j| (i.clone(), j)))
 }
 
 /// A square (represented by its top left corner position and width/height of `square_size`) that is currently a candidate for targetting by the dart throwing process.

node-graph/gcore/src/vector/vector_data.rs

@@ -337,7 +337,7 @@ impl VectorData {
 	/// Returns the number of linear segments connected to the given point.
 	pub fn connected_linear_segments(&self, point_id: PointId) -> usize {
 		self.segment_bezier_iter()
-			.filter(|(_, bez, start, end)| ((*start == point_id || *end == point_id) && matches!(bez.handles, BezierHandles::Linear)))
+			.filter(|(_, bez, start, end)| (*start == point_id || *end == point_id) && matches!(bez.handles, BezierHandles::Linear))
 			.count()
 	}
 

node-graph/graster-nodes/src/dehaze.rs

@@ -8,34 +8,33 @@ use std::cmp::{max, min};
 
 #[node_macro::node(category("Raster: Filter"))]
 async fn dehaze(_: impl Ctx, image_frame: RasterDataTable<CPU>, strength: Percentage) -> RasterDataTable<CPU> {
-	let mut result_table = RasterDataTable::default();
-
-	for mut image_frame_instance in image_frame.instance_iter() {
-		let image = image_frame_instance.instance;
-		// Prepare the image data for processing
-		let image_data = bytemuck::cast_vec(image.data.clone());
-		let image_buffer = image::Rgba32FImage::from_raw(image.width, image.height, image_data).expect("Failed to convert internal image format into image-rs data type.");
-		let dynamic_image: DynamicImage = image_buffer.into();
-
-		// Run the dehaze algorithm
-		let dehazed_dynamic_image = dehaze_image(dynamic_image, strength / 100.);
-
-		// Prepare the image data for returning
-		let buffer = dehazed_dynamic_image.to_rgba32f().into_raw();
-		let color_vec = bytemuck::cast_vec(buffer);
-		let dehazed_image = Image {
-			width: image.width,
-			height: image.height,
-			data: color_vec,
-			base64_string: None,
-		};
-
-		image_frame_instance.instance = Raster::new_cpu(dehazed_image);
-		image_frame_instance.source_node_id = None;
-		result_table.push(image_frame_instance);
-	}
-
-	result_table
+	image_frame
+		.instance_iter()
+		.map(|mut image_frame_instance| {
+			let image = image_frame_instance.instance;
+			// Prepare the image data for processing
+			let image_data = bytemuck::cast_vec(image.data.clone());
+			let image_buffer = image::Rgba32FImage::from_raw(image.width, image.height, image_data).expect("Failed to convert internal image format into image-rs data type.");
+			let dynamic_image: DynamicImage = image_buffer.into();
+
+			// Run the dehaze algorithm
+			let dehazed_dynamic_image = dehaze_image(dynamic_image, strength / 100.);
+
+			// Prepare the image data for returning
+			let buffer = dehazed_dynamic_image.to_rgba32f().into_raw();
+			let color_vec = bytemuck::cast_vec(buffer);
+			let dehazed_image = Image {
+				width: image.width,
+				height: image.height,
+				data: color_vec,
+				base64_string: None,
+			};
+
+			image_frame_instance.instance = Raster::new_cpu(dehazed_image);
+			image_frame_instance.source_node_id = None;
+			image_frame_instance
+		})
+		.collect()
 }
 
 // There is no real point in modifying these values because they do not change the final result all that much.

node-graph/graster-nodes/src/filter.rs

@@ -20,27 +20,26 @@ async fn blur(
 	/// Opt to incorrectly apply the filter with color calculations in gamma space for compatibility with the results from other software.
 	gamma: bool,
 ) -> RasterDataTable<CPU> {
-	let mut result_table = RasterDataTable::default();
-
-	for mut image_instance in image_frame.instance_iter() {
-		let image = image_instance.instance.clone();
-
-		// Run blur algorithm
-		let blurred_image = if radius < 0.1 {
-			// Minimum blur radius
-			image.clone()
-		} else if box_blur {
-			Raster::new_cpu(box_blur_algorithm(image.into_data(), radius, gamma))
-		} else {
-			Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
-		};
-
-		image_instance.instance = blurred_image;
-		image_instance.source_node_id = None;
-		result_table.push(image_instance);
-	}
-
-	result_table
+	image_frame
+		.instance_iter()
+		.map(|mut image_instance| {
+			let image = image_instance.instance.clone();
+
+			// Run blur algorithm
+			let blurred_image = if radius < 0.1 {
+				// Minimum blur radius
+				image.clone()
+			} else if box_blur {
+				Raster::new_cpu(box_blur_algorithm(image.into_data(), radius, gamma))
+			} else {
+				Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
+			};
+
+			image_instance.instance = blurred_image;
+			image_instance.source_node_id = None;
+			image_instance
+		})
+		.collect()
 }
 
 // 1D gaussian kernel