A few minor lints and docs (#1436)

* A few minor lints and docs

* Added required packages to compile on Debian-style linux
* Inlined some format args, and removed some `&` in args (they cause about 6% slowdown that compiler cannot inline)
* a few spelling mistakes

* fix fmt

editor/src/application.rs

@@ -86,11 +86,11 @@ r#"
 			block_on(crate::node_graph_executor::run_node_graph());
 			let mut res = VecDeque::new();
 			editor.poll_node_graph_evaluation(&mut res);
-			//println!("node_graph_poll: {:#?}", res);
+			//println!("node_graph_poll: {res:#?}");
 
-			//println!("in: {:#?}", message);
+			//println!("in: {message:#?}");
 			let res = editor.handle_message(message);
-			//println!("out: {:#?}", res);
+			//println!("out: {res:#?}");
 			responses.push(res);
 		}
 		let responses = responses.pop().unwrap();
@@ -100,6 +100,6 @@ r#"
 		} else {
 			panic!();
 		}
-		println!("responses: {:#?}", responses);
+		println!("responses: {responses:#?}");
 	}
 }

editor/src/dispatcher.rs

@@ -175,7 +175,7 @@ impl Dispatcher {
 							),
 						);
 					} else {
-						warn!("Called ToolMessage without an active document.\nGot {:?}", message);
+						warn!("Called ToolMessage without an active document.\nGot {message:?}");
 					}
 				}
 				Workspace(message) => {
@@ -518,7 +518,7 @@ mod test {
 			paths.iter().map(|layer| layer.to_vec()).collect::<Vec<_>>()
 		}
 		let sorted_layers = map_to_vec(editor.dispatcher.message_handlers.portfolio_message_handler.active_document().unwrap().all_layers_sorted());
-		println!("Sorted layers: {:?}", sorted_layers);
+		println!("Sorted layers: {sorted_layers:?}");
 
 		let verify_order = |handler: &mut DocumentMessageHandler| {
 			(
@@ -562,7 +562,7 @@ mod test {
 			println!();
 			println!("DisplayDialogError details:");
 			println!();
-			println!("Description: {}", value);
+			println!("Description: {value}");
 			println!("-------------------------------------------------");
 			println!();
 

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

@@ -214,7 +214,7 @@ pub enum Key {
 impl fmt::Display for Key {
 	// TODO: Relevant key labels should be localized when we get around to implementing localization/internationalization
 	fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
-		let key_name = format!("{:?}", self);
+		let key_name = format!("{self:?}");
 
 		// Writing system keys
 		const DIGIT_PREFIX: &str = "Digit";
@@ -293,14 +293,14 @@ impl fmt::Display for Key {
 			_ => key_name.as_str(),
 		};
 
-		write!(f, "{}", name)
+		write!(f, "{name}")
 	}
 }
 
 impl From<Key> for LayoutKey {
 	fn from(key: Key) -> Self {
 		Self {
-			key: format!("{:?}", key),
+			key: format!("{key:?}"),
 			label: key.to_string(),
 		}
 	}
@@ -356,7 +356,7 @@ impl fmt::Display for KeysGroup {
 			joined.truncate(joined.len() - JOINER_MARK.len());
 		}
 
-		write!(f, "{}", joined)
+		write!(f, "{joined}")
 	}
 }
 

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

@@ -140,7 +140,7 @@ impl ActionKeys {
 				}
 			}
 			Self::Keys(keys) => {
-				warn!("Calling `.to_keys()` on a `ActionKeys::Keys` is a mistake/bug. Keys are: {:?}.", keys);
+				warn!("Calling `.to_keys()` on a `ActionKeys::Keys` is a mistake/bug. Keys are: {keys:?}.");
 				String::new()
 			}
 		}

editor/src/messages/layout/layout_message_handler.rs

@@ -71,20 +71,14 @@ impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage
 				let layout = if let Some(layout) = self.layouts.get_mut(layout_target as usize) {
 					layout
 				} else {
-					warn!(
-						"UpdateLayout was called referencing an invalid layout. `widget_id: {}`, `layout_target: {:?}`",
-						widget_id, layout_target
-					);
+					warn!("UpdateLayout was called referencing an invalid layout. `widget_id: {widget_id}`, `layout_target: {layout_target:?}`",);
 					return;
 				};
 
 				let widget_holder = if let Some(widget_holder) = layout.iter_mut().find(|widget| widget.widget_id == widget_id) {
 					widget_holder
 				} else {
-					warn!(
-						"UpdateLayout was called referencing an invalid widget ID, although the layout target was valid. `widget_id: {}`, `layout_target: {:?}`",
-						widget_id, layout_target
-					);
+					warn!("UpdateLayout was called referencing an invalid widget ID, although the layout target was valid. `widget_id: {widget_id}`, `layout_target: {layout_target:?}`",);
 					return;
 				};
 

editor/src/messages/layout/utility_types/widgets/assist_widgets.rs

@@ -48,7 +48,7 @@ impl From<&str> for PivotPosition {
 			"BottomLeft" => PivotPosition::BottomLeft,
 			"BottomCenter" => PivotPosition::BottomCenter,
 			"BottomRight" => PivotPosition::BottomRight,
-			_ => panic!("Failed parsing unrecognized PivotPosition enum value '{}'", input),
+			_ => panic!("Failed parsing unrecognized PivotPosition enum value '{input}'"),
 		}
 	}
 }

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -154,7 +154,7 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 							responses.add(BroadcastEvent::DocumentIsDirty);
 						}
 					}
-					Err(e) => error!("DocumentError: {:?}", e),
+					Err(e) => error!("DocumentError: {e:?}"),
 					Ok(_) => (),
 				}
 			}
@@ -202,7 +202,7 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 			// Messages
 			AbortTransaction => {
 				if !self.undo_in_progress {
-					self.undo(responses).unwrap_or_else(|e| warn!("{}", e));
+					self.undo(responses).unwrap_or_else(|e| warn!("{e}"));
 					responses.extend([RenderDocument.into(), DocumentStructureChanged.into()]);
 				}
 			}
@@ -320,8 +320,8 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 					responses.add_front(DocumentMessage::DirtyRenderDocument);
 				}
 			}
-			DocumentHistoryBackward => self.undo(responses).unwrap_or_else(|e| warn!("{}", e)),
-			DocumentHistoryForward => self.redo(responses).unwrap_or_else(|e| warn!("{}", e)),
+			DocumentHistoryBackward => self.undo(responses).unwrap_or_else(|e| warn!("{e}")),
+			DocumentHistoryForward => self.redo(responses).unwrap_or_else(|e| warn!("{e}")),
 			DocumentStructureChanged => {
 				let data_buffer: RawBuffer = self.serialize_root().as_slice().into();
 				responses.add(FrontendMessage::UpdateDocumentLayerTreeStructure { data_buffer })
@@ -652,7 +652,7 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 				});
 			}
 			RollbackTransaction => {
-				self.rollback(responses).unwrap_or_else(|e| warn!("{}", e));
+				self.rollback(responses).unwrap_or_else(|e| warn!("{e}"));
 				responses.extend([RenderDocument.into(), DocumentStructureChanged.into()]);
 			}
 			SaveDocument => {
@@ -754,7 +754,7 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 						}
 					}
 					other => {
-						warn!("Setting blob URL for invalid layer type, which must be a `Layer` layer type. Found: `{:?}`", other);
+						warn!("Setting blob URL for invalid layer type, which must be a `Layer` layer type. Found: `{other:?}`");
 						return;
 					}
 				}
@@ -982,7 +982,7 @@ impl DocumentMessageHandler {
 		};
 		let outside_artboards_color = outside.map_or_else(|| if false { "ffffff" } else { "222222" }.to_string(), |col| col.rgba_hex());
 		let outside_artboards = match transparent_background {
-			false => format!(r##"<rect x="0" y="0" width="100%" height="100%" fill="#{}" />"##, outside_artboards_color),
+			false => format!(r##"<rect x="0" y="0" width="100%" height="100%" fill="#{outside_artboards_color}" />"##),
 			true => "".into(),
 		};
 		let matrix = transform
@@ -1055,7 +1055,7 @@ impl DocumentMessageHandler {
 			let data = self.layer_panel_entry(path.to_vec(), &render_data).ok()?;
 			(!path.is_empty()).then(|| FrontendMessage::UpdateDocumentLayerDetails { data }.into())
 		} else {
-			warn!("Tried to select non existing layer {:?}", path);
+			warn!("Tried to select non existing layer {path:?}");
 			None
 		}
 	}
@@ -1185,7 +1185,7 @@ impl DocumentMessageHandler {
 				// TODO: `indices_for_path` can return an error. We currently skip these layers and log a warning. Once this problem is solved this code can be simplified.
 				match self.document_legacy.indices_for_path(path) {
 					Err(err) => {
-						warn!("layers_sorted: Could not get indices for the layer {:?}: {:?}", path, err);
+						warn!("layers_sorted: Could not get indices for the layer {path:?}: {err:?}");
 						None
 					}
 					Ok(indices) => Some((path, indices)),
@@ -1214,7 +1214,7 @@ impl DocumentMessageHandler {
 	}
 
 	pub fn layer_metadata(&self, path: &[LayerId]) -> &LayerMetadata {
-		self.layer_metadata.get(path).unwrap_or_else(|| panic!("Editor's layer metadata for {:?} does not exist", path))
+		self.layer_metadata.get(path).unwrap_or_else(|| panic!("Editor's layer metadata for {path:?} does not exist"))
 	}
 
 	pub fn layer_metadata_mut(&mut self, path: &[LayerId]) -> &mut LayerMetadata {
@@ -1224,7 +1224,7 @@ impl DocumentMessageHandler {
 	pub fn layer_metadata_mut_no_borrow_self<'a>(layer_metadata: &'a mut HashMap<Vec<LayerId>, LayerMetadata>, path: &[LayerId]) -> &'a mut LayerMetadata {
 		layer_metadata
 			.get_mut(path)
-			.unwrap_or_else(|| panic!("Layer data cannot be found because the path {:?} does not exist", path))
+			.unwrap_or_else(|| panic!("Layer data cannot be found because the path {path:?} does not exist"))
 	}
 
 	/// Places a document into the history system
@@ -1379,7 +1379,7 @@ impl DocumentMessageHandler {
 		let data: LayerMetadata = *self
 			.layer_metadata
 			.get_mut(&path)
-			.ok_or_else(|| EditorError::Document(format!("Could not get layer metadata for {:?}", path)))?;
+			.ok_or_else(|| EditorError::Document(format!("Could not get layer metadata for {path:?}")))?;
 		let layer = self.document_legacy.layer(&path)?;
 		let entry = LayerPanelEntry::new(&data, self.document_legacy.multiply_transforms(&path)?, layer, path, render_data);
 		Ok(entry)

editor/src/messages/portfolio/document/node_graph/graph_operation_message_handler/transform_utils.rs

@@ -165,15 +165,7 @@ fn derive_transform() {
 
 					assert!(
 						new_transform.abs_diff_eq(original_transform, 1e-10),
-						"original_transform {} new_transform {} / scale {} new_scale {} / angle {} new_angle {} / shear {} / new_shear {}",
-						original_transform,
-						new_transform,
-						scale,
-						new_scale,
-						angle,
-						new_angle,
-						shear,
-						new_shear,
+						"original_transform {original_transform} new_transform {new_transform} / scale {scale} new_scale {new_scale} / angle {angle} new_angle {new_angle} / shear {shear} / new_shear {new_shear}",
 					);
 				}
 			}

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

@@ -20,7 +20,7 @@ impl MessageHandler<OverlaysMessage, (bool, &PersistentData, &InputPreprocessorM
 			#[remain::unsorted]
 			DispatchOperation(operation) => match self.overlays_document.handle_operation(*operation) {
 				Ok(_) => responses.add(OverlaysMessage::Rerender),
-				Err(e) => error!("OverlaysError: {:?}", e),
+				Err(e) => error!("OverlaysError: {e:?}"),
 			},
 
 			// Messages

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

@@ -32,7 +32,7 @@ macro_rules! derive_from {
 	($type:ty, $kind:ident) => {
 		impl From<$type> for EditorError {
 			fn from(error: $type) -> Self {
-				EditorError::$kind(format!("{:?}", error))
+				EditorError::$kind(format!("{error:?}"))
 			}
 		}
 	};

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

@@ -382,7 +382,7 @@ impl<'a> Selected<'a> {
 					let original_layer_transforms = match self.original_transforms {
 						OriginalTransforms::Layer(layer_map) => *layer_map.get(&layer).unwrap(),
 						OriginalTransforms::Path(_path_map) => {
-							warn!("Found Path variant in original_transforms, returning identity transform for layer {:?}", layer);
+							warn!("Found Path variant in original_transforms, returning identity transform for layer {layer:?}");
 							DAffine2::IDENTITY
 						}
 					};

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -161,7 +161,7 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
 								(Ok(layer), layer_metadata) => {
 									buffer.push(CopyBufferEntry { layer, layer_metadata });
 								}
-								(Err(e), _) => warn!("Could not access selected layer {:?}: {:?}", layer_path, e),
+								(Err(e), _) => warn!("Could not access selected layer {layer_path:?}: {e:?}"),
 							}
 						}
 					};
@@ -348,7 +348,7 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
 						self.load_document(document, document_id, responses);
 					}
 					Err(e) => {
-						println!("Failed to open document: {}", e);
+						println!("Failed to open document: {e}");
 						if !document_is_auto_saved {
 							responses.add(DialogMessage::DisplayDialogError {
 								title: "Failed to open document".to_string(),
@@ -385,7 +385,7 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
 			} => {
 				let paste = |entry: &CopyBufferEntry, responses: &mut VecDeque<_>| {
 					if let Some(document) = self.active_document() {
-						trace!("Pasting into folder {:?} as index: {}", &path, insert_index);
+						trace!("Pasting into folder {path:?} as index: {insert_index}");
 						let destination_path = [path.to_vec(), vec![generate_uuid()]].concat();
 
 						responses.add_front(DocumentMessage::UpdateLayerMetadata {
@@ -623,7 +623,7 @@ impl PortfolioMessageHandler {
 
 		match new_doc_title_num {
 			1 => DEFAULT_DOCUMENT_NAME.to_string(),
-			_ => format!("{} {}", DEFAULT_DOCUMENT_NAME, new_doc_title_num),
+			_ => format!("{DEFAULT_DOCUMENT_NAME} {new_doc_title_num}"),
 		}
 	}
 
@@ -713,7 +713,7 @@ impl PortfolioMessageHandler {
 		};
 
 		self.executor.poll_node_graph_evaluation(&mut active_document.document_legacy, responses).unwrap_or_else(|e| {
-			log::error!("Error while evaluating node graph: {}", e);
+			log::error!("Error while evaluating node graph: {e}");
 		});
 	}
 }

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

@@ -60,16 +60,16 @@ impl OverlayRenderer {
 		self.layer_overlay_visibility(document, layer, true, responses);
 
 		let outline_cache = self.shape_overlay_cache.get(&layer);
-		trace!("Overlay: Outline cache {:?}", &outline_cache);
+		trace!("Overlay: Outline cache {outline_cache:?}");
 
 		// Create an outline if we do not have a cached one
 		if outline_cache.is_none() {
 			let outline_path = self.create_shape_outline_overlay(graphene_core::vector::Subpath::from_bezier_rs(subpaths), responses);
 			self.shape_overlay_cache.insert(layer, outline_path.clone());
 			Self::place_outline_overlays(outline_path.clone(), &transform, responses);
-			trace!("Overlay: Creating new outline {:?}", &outline_path);
+			trace!("Overlay: Creating new outline {outline_path:?}");
 		} else if let Some(outline_path) = outline_cache {
-			trace!("Overlay: Updating overlays for {:?} owning layer: {:?}", outline_path, layer);
+			trace!("Overlay: Updating overlays for {outline_path:?} owning layer: {layer:?}");
 			Self::modify_outline_overlays(outline_path.clone(), graphene_core::vector::Subpath::from_bezier_rs(subpaths), responses);
 			Self::place_outline_overlays(outline_path.clone(), &transform, responses);
 		}
@@ -294,7 +294,7 @@ impl OverlayRenderer {
 	/// Removes the manipulator overlays from the overlay document.
 	fn remove_manipulator_group_overlays(overlay_paths: &ManipulatorGroupOverlays, responses: &mut VecDeque<Message>) {
 		overlay_paths.iter().flatten().for_each(|layer_id| {
-			trace!("Overlay: Sending delete message for: {:?}", layer_id);
+			trace!("Overlay: Sending delete message for: {layer_id:?}");
 			responses.add(DocumentMessage::Overlays(Operation::DeleteLayer { path: layer_id.clone() }.into()));
 		});
 	}

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

@@ -71,7 +71,7 @@ impl ShapeState {
 		}
 
 		if let Some((layer, manipulator_point_id)) = self.find_nearest_point_indices(document, mouse_position, select_threshold) {
-			trace!("Selecting... manipulator point: {:?}", manipulator_point_id);
+			trace!("Selecting... manipulator point: {manipulator_point_id:?}");
 
 			let subpaths = get_subpaths(layer, document)?;
 			let manipulator_group = get_manipulator_groups(subpaths).find(|group| group.id == manipulator_point_id.group)?;
@@ -631,7 +631,7 @@ impl ShapeState {
 			if let Some((manipulator_point_id, distance_squared)) = Self::closest_point_in_layer(document, layer, mouse_position) {
 				// Choose the first point under the threshold
 				if distance_squared < select_threshold_squared {
-					trace!("Selecting... manipulator point: {:?}", manipulator_point_id);
+					trace!("Selecting... manipulator point: {manipulator_point_id:?}");
 					return Some((layer, manipulator_point_id));
 				}
 			}

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

@@ -317,7 +317,7 @@ impl SelectToolData {
 			// let layer = match document.document_legacy.layer(layer_path) {
 			// 	Ok(layer) => layer.clone(),
 			// 	Err(e) => {
-			// 		warn!("Could not access selected layer {:?}: {:?}", layer_path, e);
+			// 		warn!("Could not access selected layer {layer_path:?}: {e:?}");
 			// 		continue;
 			// 	}
 			// };

editor/src/messages/tool/utility_types.rs

@@ -438,10 +438,7 @@ pub fn tool_message_to_tool_type(tool_message: &ToolMessage) -> ToolType {
 		// ToolMessage::Relight(_) => ToolType::Relight,
 		ToolMessage::Imaginate(_) => ToolType::Imaginate,
 		ToolMessage::Frame(_) => ToolType::Frame,
-		_ => panic!(
-			"Conversion from ToolMessage to ToolType impossible because the given ToolMessage does not have a matching ToolType. Got: {:?}",
-			tool_message
-		),
+		_ => panic!("Conversion from ToolMessage to ToolType impossible because the given ToolMessage does not have a matching ToolType. Got: {tool_message:?}"),
 	}
 }
 
@@ -475,10 +472,7 @@ pub fn tool_type_to_activate_tool_message(tool_type: ToolType) -> ToolMessageDis
 		// ToolType::Relight => ToolMessageDiscriminant::ActivateToolRelight,
 		ToolType::Imaginate => ToolMessageDiscriminant::ActivateToolImaginate,
 		ToolType::Frame => ToolMessageDiscriminant::ActivateToolFrame,
-		_ => panic!(
-			"Conversion from ToolType to ToolMessage impossible because the given ToolType does not have a matching ToolMessage. Got: {:?}",
-			tool_type
-		),
+		_ => panic!("Conversion from ToolType to ToolMessage impossible because the given ToolType does not have a matching ToolMessage. Got: {tool_type:?}"),
 	}
 }
 

editor/src/node_graph_executor.rs

@@ -204,7 +204,7 @@ impl NodeRuntime {
 
 		assert_ne!(proto_network.nodes.len(), 0, "No protonodes exist?");
 		if let Err(e) = self.executor.update(proto_network).await {
-			error!("Failed to update executor:\n{}", e);
+			error!("Failed to update executor:\n{e}");
 			return Err(e);
 		}
 
@@ -213,7 +213,7 @@ impl NodeRuntime {
 		let result = match self.executor.input_type() {
 			Some(t) if t == concrete!(WasmEditorApi) => (&self.executor).execute(editor_api).await.map_err(|e| e.to_string()),
 			Some(t) if t == concrete!(()) => (&self.executor).execute(()).await.map_err(|e| e.to_string()),
-			Some(t) => Err(format!("Invalid input type {:?}", t)),
+			Some(t) => Err(format!("Invalid input type {t:?}")),
 			_ => Err("No input type".to_string()),
 		}?;
 
@@ -501,7 +501,7 @@ impl NodeGraphExecutor {
 					self.thumbnails = new_thumbnails;
 					document.metadata.update_transforms(new_transforms, new_upstream_transforms);
 					document.metadata.update_click_targets(new_click_targets);
-					let node_graph_output = result.map_err(|e| format!("Node graph evaluation failed: {:?}", e))?;
+					let node_graph_output = result.map_err(|e| format!("Node graph evaluation failed: {e:?}"))?;
 					let execution_context = self.futures.remove(&generation_id).ok_or_else(|| "Invalid generation ID".to_string())?;
 					responses.extend(updates);
 					self.process_node_graph_output(node_graph_output, execution_context.layer_path.clone(), responses, execution_context.document_id)?;
@@ -610,7 +610,7 @@ impl NodeGraphExecutor {
 				responses.add(DocumentMessage::RenderScrollbars);
 			}
 			_ => {
-				return Err(format!("Invalid node graph output type: {:#?}", node_graph_output));
+				return Err(format!("Invalid node graph output type: {node_graph_output:#?}"));
 			}
 		};
 		Ok(())