WIP: New error message

Author: adamgerhant

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

@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{DocumentNodeImplementation, InlineRust, NodeInput};
-use graph_craft::proto::GraphErrors;
+use graph_craft::proto::{GraphError, GraphErrorType, GraphErrors};
 use graph_craft::{Type, concrete};
 use graphene_std::uuid::NodeId;
 use interpreted_executor::dynamic_executor::{NodeTypes, ResolvedDocumentNodeTypesDelta};
@@ -129,7 +129,13 @@ impl NodeNetworkInterface {
 							InputConnector::Export(_) => false,
 						})
 					}
-					DocumentNodeImplementation::ProtoNode(_) => self.resolved_types.node_graph_errors.iter().any(|error| error.node_path == node_path),
+					DocumentNodeImplementation::ProtoNode(_) => self.resolved_types.node_graph_errors.iter().any(|error| {
+						error.node_path == node_path
+							&& match error.error {
+								GraphErrorType::InvalidImplementations { inputs, error_inputs } => error_inputs.iter().any(|solution| solution.iter().any(|(index, _)| index == *input_index)),
+								_ => True,
+							}
+					}),
 					DocumentNodeImplementation::Extract => false,
 				}
 			}

node-graph/graph-craft/src/proto.rs

@@ -542,7 +542,9 @@ pub enum GraphErrorType {
 	UnexpectedGenerics { index: usize, inputs: Vec<Type> },
 	NoImplementations,
 	NoConstructor,
-	InvalidImplementations { inputs: String, error_inputs: Vec<Vec<(usize, (Type, Type))>> },
+	// The first vec represents a list of correct NodeIOTypes
+	// The second vec represents what the input index and what it expects
+	InvalidImplementations { inputs: String, error_inputs: Vec<Vec<(usize, Type)>> },
 	MultipleImplementations { inputs: String, valid: Vec<NodeIOTypes> },
 }
 impl Debug for GraphErrorType {
@@ -554,31 +556,26 @@ impl Debug for GraphErrorType {
 			GraphErrorType::NoImplementations => write!(f, "No implementations found"),
 			GraphErrorType::NoConstructor => write!(f, "No construct found for node"),
 			GraphErrorType::InvalidImplementations { inputs, error_inputs } => {
-				let format_error = |(index, (found, expected)): &(usize, (Type, Type))| {
-					let index = index + 1;
-					format!(
-						"\
-						• Input {index}:\n\
-						…found:       {found}\n\
-						…expected: {expected}\
-						"
-					)
-				};
-				let format_error_list = |errors: &Vec<(usize, (Type, Type))>| errors.iter().map(format_error).collect::<Vec<_>>().join("\n");
-				let mut errors = error_inputs.iter().map(format_error_list).collect::<Vec<_>>();
-				errors.sort();
-				let errors = errors.join("\n");
-				let incompatibility = if errors.chars().filter(|&c| c == '•').count() == 1 {
-					"This input type is incompatible:"
-				} else {
-					"These input types are incompatible:"
-				};
+				let mut solutions = error_inputs
+					.iter()
+					.enumerate()
+					.map(|(solution_index, expected_inputs)| {
+						format!(
+							"• Solution {}{}",
+							solution_index + 1,
+							expected_inputs
+								.map(|(index, expected_type)| format!("Input {} expected: {}\n", index + 1, expected_type))
+								.collect::<String>()
+						)
+					})
+					.collect::<Vec<_>>()
+					.join("\n");
 
 				write!(
 					f,
 					"\
-					{incompatibility}\n\
-					{errors}\n\
+					Invalid input solutions:\n\
+					{solutions}\n\
 					\n\
 					The node is currently receiving all of the following input types:\n\
 					{inputs}\n\
@@ -766,10 +763,7 @@ impl TypingContext {
 						.zip([&node_io.call_argument].into_iter().chain(&node_io.inputs).cloned())
 						.enumerate()
 						.filter(|(_, (p1, p2))| !valid_type(p1, p2))
-						.map(|(index, ty)| {
-							let i = node.original_location.inputs(index).min_by_key(|s| s.node.len()).map(|s| s.index).unwrap_or(index);
-							(i, ty)
-						})
+						.map(|(index, (_, expected))| (index, expected))
 						.collect::<Vec<_>>();
 					if current_errors.len() < best_errors {
 						best_errors = current_errors.len();

node-graph/libraries/core-types/src/types.rs

@@ -369,7 +369,7 @@ impl std::fmt::Debug for Type {
 			Self::Concrete(ty) => format!("Concrete<{}, {:?}>", ty.name, ty.id),
 			#[cfg(not(feature = "type_id_logging"))]
 			Self::Concrete(ty) => format_type(&ty.name),
-			Self::Fn(call_arg, return_value) => format!("{return_value:?} called with {call_arg:?}"),
+			Self::Fn(call_arg, return_value) => format!("{return_value:?}"),
 			Self::Future(ty) => format!("{ty:?}"),
 		};
 		let result = result.replace("Option<Arc<OwnedContextImpl>>", "Context");
@@ -382,7 +382,7 @@ impl std::fmt::Display for Type {
 		let result = match self {
 			Type::Generic(name) => name.to_string(),
 			Type::Concrete(ty) => format_type(&ty.name),
-			Type::Fn(call_arg, return_value) => format!("{return_value} called with {call_arg}"),
+			Type::Fn(call_arg, return_value) => format!("{return_value}"),
 			Type::Future(ty) => ty.to_string(),
 		};
 		let result = result.replace("Option<Arc<OwnedContextImpl>>", "Context");