Fix generic type resolution

Author: TrueDoctor

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -2,8 +2,8 @@ use super::node_properties;
 use super::utility_types::FrontendNodeType;
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::portfolio::document::utility_types::network_interface::{
-	DocumentNodeMetadata, DocumentNodePersistentMetadata, NodeNetworkInterface, NodeNetworkMetadata, NodeNetworkPersistentMetadata, NodeTemplate, NodeTypePersistentMetadata, NumberInputSettings,
-	PropertiesRow, Vec2InputSettings, WidgetOverride,
+	DocumentNodeMetadata, DocumentNodePersistentMetadata, NodeNetworkInterface, NodeNetworkMetadata, NodeNetworkPersistentMetadata, NodePersistentMetadata, NodePosition, NodeTemplate,
+	NodeTypePersistentMetadata, NumberInputSettings, PropertiesRow, Vec2InputSettings, WidgetOverride,
 };
 use crate::messages::portfolio::utility_types::PersistentData;
 use crate::messages::prelude::Message;
@@ -2734,7 +2734,6 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 					match inputs.len() {
 						1 => {
 							let input = inputs.iter().next().unwrap();
-							let fn_input = input.fn_input().expect("Node inputs should have a function type");
 							let input_ty = input.nested_type();
 							let into_node_identifier = ProtoNodeIdentifier {
 								name: format!("graphene_core::ops::IntoNode<{}>", input_ty.clone()).into(),
@@ -2782,6 +2781,13 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			.collect();
 		nodes.insert(NodeId(input_count as u64), document_node);
 		node_names.insert(NodeId(input_count as u64), display_name.to_string());
+		let node_type_metadata = |id: NodeId| {
+			NodeTypePersistentMetadata::Node(NodePersistentMetadata::new(NodePosition::Absolute(if id.0 == input_count as u64 {
+				IVec2::default()
+			} else {
+				IVec2 { x: -10, y: id.0 as i32 }
+			})))
+		};
 
 		let node = DocumentNodeDefinition {
 			identifier: display_name,
@@ -2822,10 +2828,15 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							node_metadata: node_names
 								.into_iter()
 								.map(|(id, display_name)| {
+									let node_type_metadata = node_type_metadata(id);
 									(
 										id,
 										DocumentNodeMetadata {
-											persistent_metadata: DocumentNodePersistentMetadata { display_name, ..Default::default() },
+											persistent_metadata: DocumentNodePersistentMetadata {
+												display_name,
+												node_type_metadata,
+												..Default::default()
+											},
 											..Default::default()
 										},
 									)

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

@@ -6438,6 +6438,12 @@ pub struct NodePersistentMetadata {
 	position: NodePosition,
 }
 
+impl NodePersistentMetadata {
+	pub fn new(position: NodePosition) -> Self {
+		Self { position }
+	}
+}
+
 /// A layer can either be position as Absolute or in a Stack
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum LayerPosition {

node-graph/gcore/src/types.rs

@@ -2,7 +2,6 @@ use core::any::TypeId;
 
 #[cfg(not(feature = "std"))]
 pub use alloc::borrow::Cow;
-use spirv_std::image::sample_with::NoneTy;
 #[cfg(feature = "std")]
 pub use std::borrow::Cow;
 

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

@@ -838,11 +838,12 @@ fn collect_generics(types: &NodeIOTypes) -> Vec<Cow<'static, str>> {
 
 /// Checks if a generic type can be substituted with a concrete type and returns the concrete type
 fn check_generic(types: &NodeIOTypes, input: &Type, parameters: &[Type], generic: &str) -> Result<Type, String> {
-	let inputs = [(&types.call_argument, input)]
+	let inputs = [(Some(&types.call_argument), Some(input))]
 		.into_iter()
-		.chain(types.inputs.iter().map(|x| x.nested_type()).zip(parameters.iter().map(|x| x.nested_type())));
-	let concrete_inputs = inputs.filter(|(ni, _)| matches!(ni, Type::Generic(input) if generic == input));
-	let mut outputs = concrete_inputs.map(|(_, out)| out);
+		.chain(types.inputs.iter().map(|x| x.fn_input()).zip(parameters.iter().map(|x| x.fn_input())))
+		.chain(types.inputs.iter().map(|x| x.fn_output()).zip(parameters.iter().map(|x| x.fn_output())));
+	let concrete_inputs = inputs.filter(|(ni, _)| matches!(ni, Some(Type::Generic(input)) if generic == input));
+	let mut outputs = concrete_inputs.flat_map(|(_, out)| out);
 	let out_ty = outputs
 		.next()
 		.ok_or_else(|| format!("Generic output type {generic} is not dependent on input {input:?} or parameters {parameters:?}",))?;