Avoid panics during document migration

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

@@ -674,7 +674,7 @@ impl NodeNetworkInterface {
 							let input_type = self.input_type(&InputConnector::node(*node_id, iterator_index), network_path).0;
 							// Value inputs are stored as concrete, so they are compared to the nested type. Node inputs are stored as fn, so they are compared to the entire type.
 							// For example a node input of (Footprint) -> VectorData would not be compatible with () -> VectorData
-							node_io.inputs[iterator_index].clone().nested_type() == &input_type || node_io.inputs[iterator_index] == input_type
+							node_io.inputs.get(iterator_index).map(|ty| ty.nested_type().clone()).as_ref() == Some(&input_type) || node_io.inputs.get(iterator_index) == Some(&input_type)
 						});
 						if valid_implementation { node_io.inputs.get(*input_index).cloned() } else { None }
 					})

editor/src/messages/portfolio/document_migration.rs

@@ -7,6 +7,7 @@ use crate::messages::portfolio::document::utility_types::network_interface::{Inp
 use crate::messages::prelude::DocumentMessageHandler;
 use bezier_rs::Subpath;
 use glam::IVec2;
+use graph_craft::document::DocumentNode;
 use graph_craft::document::{DocumentNodeImplementation, NodeInput, value::TaggedValue};
 use graphene_std::text::TypesettingConfig;
 use graphene_std::uuid::NodeId;
@@ -217,9 +218,14 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 		.map(|(node_id, node, path)| (*node_id, node.clone(), path))
 		.collect::<Vec<(NodeId, graph_craft::document::DocumentNode, Vec<NodeId>)>>();
 	for (node_id, node, network_path) in &nodes {
+		migrate_node(node_id, node, network_path, document, reset_node_definitions_on_open);
+	}
+}
+
+fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId], document: &mut DocumentMessageHandler, reset_node_definitions_on_open: bool) -> Option<()> {
 	if reset_node_definitions_on_open {
 		if let Some(Some(reference)) = document.network_interface.reference(node_id, network_path) {
-				let Some(node_definition) = resolve_document_node_type(reference) else { continue };
+			let node_definition = resolve_document_node_type(reference)?;
 			document.network_interface.replace_implementation(node_id, network_path, &mut node_definition.default_node_template());
 		}
 	}
@@ -231,18 +237,16 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 			.set_manual_compostion(node_id, network_path, graph_craft::concrete!(graphene_std::Context).into());
 	}
 
-		let Some(Some(reference)) = document.network_interface.reference(node_id, network_path).cloned() else {
 	// Only nodes that have not been modified and still refer to a definition can be updated
-			continue;
+	let reference = document.network_interface.reference(node_id, network_path).cloned().flatten()?;
-		};
 	let reference = &reference;
 
 	let inputs_count = node.inputs.len();
 
 	// Upgrade Stroke node to reorder parameters and add "Align" and "Paint Order" (#2644)
 	if reference == "Stroke" && inputs_count == 8 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		let align_input = NodeInput::value(TaggedValue::StrokeAlign(StrokeAlign::Center), false);
 		let paint_order_input = NodeInput::value(TaggedValue::PaintOrder(PaintOrder::StrokeAbove), false);
@@ -272,48 +276,51 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 			.implementation(node_id, network_path)
 			.and_then(|implementation| implementation.get_proto_node());
 		if identifier.map(|identifier| &identifier.name) != Some(&"graphene_core::vector::generator_nodes::SplineNode".into()) {
-				continue;
+			return None;
 		}
 
 		// Obtain the document node for the given node ID, extract the vector points, and create vector data from the list of points
-			let node = document.network_interface.document_node(node_id, network_path).unwrap();
+		let node = document.network_interface.document_node(node_id, network_path)?;
 		let Some(TaggedValue::VecDVec2(points)) = node.inputs.get(1).and_then(|tagged_value| tagged_value.as_value()) else {
 			log::error!("The old Spline node's input at index 1 is not a TaggedValue::VecDVec2");
-				continue;
+			return None;
 		};
 		let vector_data = VectorData::from_subpath(Subpath::from_anchors_linear(points.to_vec(), false));
 
 		// Retrieve the output connectors linked to the "Spline" node's output port
-			let spline_outputs = document
+		let Some(spline_outputs) = document.network_interface.outward_wires(network_path)?.get(&OutputConnector::node(*node_id, 0)).cloned() else {
-				.network_interface
+			log::error!("Vec of InputConnector Spline node is connected to its output port 0.");
-				.outward_wires(network_path)
+			return None;
-				.unwrap()
+		};
-				.get(&OutputConnector::node(*node_id, 0))
-				.expect("Vec of InputConnector Spline node is connected to its output port 0.")
-				.clone();
 
 		// Get the node's current position in the graph
 		let Some(node_position) = document.network_interface.position(node_id, network_path) else {
 			log::error!("Could not get position of spline node.");
-				continue;
+			return None;
 		};
 
 		// Get the "Path" node definition and fill it in with the vector data and default vector modification
-			let path_node_type = resolve_document_node_type("Path").expect("Path node does not exist.");
+		let Some(path_node_type) = resolve_document_node_type("Path") else {
+			log::error!("Path node does not exist.");
+			return None;
+		};
 		let path_node = path_node_type.node_template_input_override([
 			Some(NodeInput::value(TaggedValue::VectorData(VectorDataTable::new(vector_data)), true)),
 			Some(NodeInput::value(TaggedValue::VectorModification(Default::default()), false)),
 		]);
 
 		// Get the "Spline" node definition and wire it up with the "Path" node as input
-			let spline_node_type = resolve_document_node_type("Spline").expect("Spline node does not exist.");
+		let Some(spline_node_type) = resolve_document_node_type("Spline") else {
+			log::error!("Spline node does not exist.");
+			return None;
+		};
 		let spline_node = spline_node_type.node_template_input_override([Some(NodeInput::node(NodeId(1), 0))]);
 
 		// Create a new node group with the "Path" and "Spline" nodes and generate new node IDs for them
 		let nodes = vec![(NodeId(1), path_node), (NodeId(0), spline_node)];
 		let new_ids = nodes.iter().map(|(id, _)| (*id, NodeId::new())).collect::<HashMap<_, _>>();
-			let new_spline_id = *new_ids.get(&NodeId(0)).unwrap();
+		let new_spline_id = *new_ids.get(&NodeId(0))?;
-			let new_path_id = *new_ids.get(&NodeId(1)).unwrap();
+		let new_path_id = *new_ids.get(&NodeId(1))?;
 
 		// Remove the old "Spline" node from the document
 		document.network_interface.delete_nodes(vec![*node_id], false, network_path);
@@ -335,9 +342,9 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Upgrade Text node to include line height and character spacing, which were previously hardcoded to 1, from https://github.com/GraphiteEditor/Graphite/pull/2016
 	if reference == "Text" && inputs_count != 9 {
-			let mut template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut template);
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -392,10 +399,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Upgrade Sine, Cosine, and Tangent nodes to include a boolean input for whether the output should be in radians, which was previously the only option but is now not the default
 	if (reference == "Sine" || reference == "Cosine" || reference == "Tangent") && inputs_count == 1 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document
@@ -405,10 +412,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Upgrade the Modulo node to include a boolean input for whether the output should be always positive, which was previously not an option
 	if reference == "Modulo" && inputs_count == 2 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -419,10 +426,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Upgrade the Mirror node to add the `keep_original` boolean input
 	if reference == "Mirror" && inputs_count == 3 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -434,12 +441,12 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Upgrade the Mirror node to add the `reference_point` input and change `offset` from `DVec2` to `f64`
 	if reference == "Mirror" && inputs_count == 4 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
-			let Some(&TaggedValue::DVec2(old_offset)) = old_inputs[1].as_value() else { return };
+		let Some(&TaggedValue::DVec2(old_offset)) = old_inputs[1].as_value() else { return None };
 		let old_offset = if old_offset.x.abs() > old_offset.y.abs() { old_offset.x } else { old_offset.y };
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
@@ -464,7 +471,7 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Image" && inputs_count == 1 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
 		// Insert a new empty input for the image
@@ -473,10 +480,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Noise Pattern" && inputs_count == 15 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document
 			.network_interface
@@ -487,20 +494,20 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Instance on Points" && inputs_count == 2 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
 	}
 
 	if reference == "Morph" && inputs_count == 4 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -509,10 +516,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Brush" && inputs_count == 4 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		// We have removed the second input ("bounds"), so we don't add index 1 and we shift the rest of the inputs down by one
@@ -521,10 +528,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Flatten Vector Elements" {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 
@@ -532,10 +539,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Remove Handles" {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document
@@ -549,10 +556,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Generate Handles" {
-			let mut node_template = resolve_document_node_type("Auto-Tangents").unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type("Auto-Tangents")?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -564,10 +571,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Merge by Distance" && inputs_count == 2 {
-			let mut node_template = resolve_document_node_type(reference).unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type(reference)?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -579,10 +586,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Spatial Merge by Distance" {
-			let mut node_template = resolve_document_node_type("Merge by Distance").unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type("Merge by Distance")?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 
 		document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
 		document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
@@ -596,10 +603,10 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	}
 
 	if reference == "Sample Points" && inputs_count == 5 {
-			let mut node_template = resolve_document_node_type("Sample Polyline").unwrap().default_node_template();
+		let mut node_template = resolve_document_node_type("Sample Polyline")?.default_node_template();
 		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
 
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
 		let new_spacing_value = NodeInput::value(TaggedValue::PointSpacingType(graphene_std::vector::misc::PointSpacingType::Separation), false);
 		let new_quantity_value = NodeInput::value(TaggedValue::U32(100), false);
 
@@ -619,8 +626,7 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 		// Get the inputs, obtain the quantity value, and put the inputs back
 		let quantity_value = document
 			.network_interface
-				.input_from_connector(&InputConnector::Node { node_id: *node_id, input_index: 3 }, network_path)
+			.input_from_connector(&InputConnector::Node { node_id: *node_id, input_index: 3 }, network_path)?;
-				.unwrap();
 
 		if let NodeInput::Value { tagged_value, exposed } = quantity_value {
 			if let TaggedValue::F64(value) = **tagged_value {
@@ -632,11 +638,11 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 	// Make the "Grid" node, if its input of index 3 is a DVec2 for "angles" instead of a u32 for the "columns" input that now succeeds "angles", move the angle to index 5 (after "columns" and "rows")
 	if reference == "Grid" && inputs_count == 6 {
-			let node_definition = resolve_document_node_type(reference).unwrap();
+		let node_definition = resolve_document_node_type(reference)?;
 		let mut new_node_template = node_definition.default_node_template();
 
-			let mut current_node_template = document.network_interface.create_node_template(node_id, network_path).unwrap();
+		let mut current_node_template = document.network_interface.create_node_template(node_id, network_path)?;
-			let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut new_node_template).unwrap();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut new_node_template)?;
 		let index_3_value = old_inputs.get(3).cloned();
 
 		let mut upgraded = false;
@@ -664,26 +670,24 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 	document.network_interface.load_structure();
 	let all_layers = LayerNodeIdentifier::ROOT_PARENT.descendants(document.network_interface.document_metadata()).collect::<Vec<_>>();
 	for layer in all_layers {
-			let Some((downstream_node, input_index)) = document
+		let (downstream_node, input_index) = document
 			.network_interface
 			.outward_wires(&[])
 			.and_then(|outward_wires| outward_wires.get(&OutputConnector::node(layer.to_node(), 0)))
 			.and_then(|outward_wires| outward_wires.first())
-				.and_then(|input_connector| input_connector.node_id().map(|node_id| (node_id, input_connector.input_index())))
+			.and_then(|input_connector| input_connector.node_id().map(|node_id| (node_id, input_connector.input_index())))?;
-			else {
-				continue;
-			};
 		// If the downstream node is a layer and the input is the first input and the current layer is not in a stack
 		if input_index == 0 && document.network_interface.is_layer(&downstream_node, &[]) && !document.network_interface.is_stack(&layer.to_node(), &[]) {
 			// Ensure the layer is horizontally aligned with the downstream layer to prevent changing the layout of old files
 			let (Some(layer_position), Some(downstream_position)) = (document.network_interface.position(&layer.to_node(), &[]), document.network_interface.position(&downstream_node, &[])) else {
 				log::error!("Could not get position for layer {:?} or downstream node {} when opening file", layer.to_node(), downstream_node);
-					continue;
+				return None;
 			};
 			if layer_position.x == downstream_position.x {
 				document.network_interface.set_stack_position_calculated_offset(&layer.to_node(), &downstream_node, &[]);
 			}
 		}
 	}
-	}
+
+	Some(())
 }