Refactor the node macro and simply most of the node implementations (#1942)

* Add support structure for new node macro to gcore

* Fix compile issues and code generation

* Implement new node_fn macro

* Implement property translation

* Fix NodeIO type generation

* Start translating math nodes

* Move node implementation to outer scope to allow usage of local imports

* Add expose attribute to allow controlling the parameter exposure

* Add rust analyzer support for #[implementations] attribute

* Migrate logic nodes

* Handle where clause properly

* Implement argument ident pattern preservation

* Implement adjustment layer mapping

* Fix node registry types

* Fix module paths

* Improve demo artwork comptibility

* Improve macro error reporting

* Fix handling of impl node implementations

* Fix nodeio type computation

* Fix opacity node and graph type resolution

* Fix loading of demo artworks

* Fix eslint

* Fix typo in macro test

* Remove node definitions for Adjustment Nodes

* Fix type alias property generation and make adjustments footprint aware

* Convert vector nodes

* Implement path overrides

* Fix stroke node

* Fix painted dreams

* Implement experimental type level specialization

* Fix poisson disk sampling -> all demo artworks should work again

* Port text node + make node macro more robust by implementing lifetime substitution

* Fix vector node tests

* Fix red dress demo + ci

* Fix clippy warnings

* Code review

* Fix primary input issues

* Improve math nodes and audit others

* Set no_properties when no automatic properties are derived

* Port vector generator nodes (could not derive all definitions yet)

* Various QA changes and add min/max/mode_range to number parameters

* Add min and max for f64 and u32

* Convert gpu nodes and clean up unused nodes

* Partially port transform node

* Allow implementations on call arg

* Port path modify node

* Start porting graphic element nodes

* Transform nodes in graphic_element.rs

* Port brush node

* Port nodes in wasm_executior

* Rename node macro

* Fix formatting

* Fix Mandelbrot node

* Formatting

* Fix Load Image and Load Resource nodes, add scope input to node macro

* Remove unnecessary underscores

* Begin attemping to make nodes resolution-aware

* Infer a generic manual compositon type on generic call arg

* Various fixes and work towards merging

* Final changes for merge!

* Fix tests, probably

* More free line removals!

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/graph-craft/Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT OR Apache-2.0"
 [features]
 default = ["dealloc_nodes"]
 serde = ["dep:serde", "graphene-core/serde", "glam/serde", "bezier-rs/serde"]
-dealloc_nodes = []
+dealloc_nodes = ["graphene-core/dealloc_nodes"]
 wgpu = []
 tokio = ["dep:tokio"]
 wayland = []

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

@@ -1,7 +1,7 @@
 use crate::document::value::TaggedValue;
 use crate::proto::{ConstructionArgs, ProtoNetwork, ProtoNode, ProtoNodeInput};
 
-use dyn_any::{DynAny, StaticType};
+use dyn_any::DynAny;
 use graphene_core::memo::MemoHashGuard;
 pub use graphene_core::uuid::generate_uuid;
 pub use graphene_core::uuid::NodeId;
@@ -275,6 +275,12 @@ impl DocumentNode {
 		let DocumentNodeImplementation::ProtoNode(fqn) = self.implementation else {
 			unreachable!("tried to resolve not flattened node on resolved node {self:?}");
 		};
+
+		// TODO replace with proper generics removal
+		let identifier = match fqn.name.clone().split_once('<') {
+			Some((path, _generics)) => ProtoNodeIdentifier { name: Cow::Owned(path.to_string()) },
+			_ => ProtoNodeIdentifier { name: fqn.name },
+		};
 		let (input, mut args) = if let Some(ty) = self.manual_composition {
 			(ProtoNodeInput::ManualComposition(ty), ConstructionArgs::Nodes(vec![]))
 		} else {
@@ -314,7 +320,7 @@ impl DocumentNode {
 			}));
 		}
 		ProtoNode {
-			identifier: fqn,
+			identifier,
 			input,
 			construction_args: args,
 			original_location: self.original_location,

node-graph/graph-craft/src/document/value.rs

@@ -15,6 +15,7 @@ pub use glam::{DAffine2, DVec2, IVec2, UVec2};
 use std::fmt::Display;
 use std::hash::Hash;
 use std::marker::PhantomData;
+use std::str::FromStr;
 pub use std::sync::Arc;
 
 /// Macro to generate the tagged value enum.
@@ -82,32 +83,31 @@ macro_rules! tagged_value {
 					_ => Err(format!("Cannot convert {:?} to TaggedValue", DynAny::type_name(input.as_ref()))),
 				}
 			}
-			pub fn from_type(input: &Type) -> Self {
+			pub fn from_type(input: &Type) -> Option<Self> {
 				match input {
 					Type::Generic(_) => {
-						log::warn!("Generic type should be resolved");
-						TaggedValue::None
+						None
 					}
 					Type::Concrete(concrete_type) => {
-						let Some(internal_id) = concrete_type.id else {
-							return TaggedValue::None;
-						};
+						let internal_id = concrete_type.id?;
 						use std::any::TypeId;
 						// TODO: Add default implementations for types such as TaggedValue::Subpaths, and use the defaults here and in document_node_types
 						// Tries using the default for the tagged value type. If it not implemented, then uses the default used in document_node_types. If it is not used there, then TaggedValue::None is returned.
-						match internal_id {
+						Some(match internal_id {
 							x if x == TypeId::of::<()>() => TaggedValue::None,
 							$( x if x == TypeId::of::<$ty>() => TaggedValue::$identifier(Default::default()), )*
-							_ => TaggedValue::None,
-						}
+							_ => return None,
+						})
 					}
 					Type::Fn(_, output) => TaggedValue::from_type(output),
 					Type::Future(_) => {
-						log::warn!("Future type not used");
-						TaggedValue::None
+						None
 					}
 				}
 			}
+			pub fn from_type_or_none(input: &Type) -> Self {
+				Self::from_type(input).unwrap_or(TaggedValue::None)
+			}
 		}
 	};
 }
@@ -160,7 +160,6 @@ tagged_value! {
 	GradientType(graphene_core::vector::style::GradientType),
 	#[serde(alias = "GradientPositions")] // TODO: Eventually remove this alias (probably starting late 2024)
 	GradientStops(graphene_core::vector::style::GradientStops),
-	Quantization(graphene_core::quantization::QuantizationChannels),
 	OptionalColor(Option<graphene_core::raster::color::Color>),
 	#[serde(alias = "ManipulatorGroupIds")] // TODO: Eventually remove this alias (probably starting late 2024)
 	PointIds(Vec<graphene_core::vector::PointId>),
@@ -196,6 +195,31 @@ impl TaggedValue {
 		}
 	}
 
+	pub fn from_primitive_string(string: &str, ty: &Type) -> Option<Self> {
+		match ty {
+			Type::Generic(_) => None,
+			Type::Concrete(concrete_type) => {
+				let internal_id = concrete_type.id?;
+				use std::any::TypeId;
+				// TODO: Add default implementations for types such as TaggedValue::Subpaths, and use the defaults here and in document_node_types
+				// Tries using the default for the tagged value type. If it not implemented, then uses the default used in document_node_types. If it is not used there, then TaggedValue::None is returned.
+				let ty = match internal_id {
+					x if x == TypeId::of::<()>() => TaggedValue::None,
+					x if x == TypeId::of::<String>() => TaggedValue::String(string.into()),
+					x if x == TypeId::of::<f64>() => FromStr::from_str(string).map(TaggedValue::F64).ok()?,
+					x if x == TypeId::of::<u64>() => FromStr::from_str(string).map(TaggedValue::U64).ok()?,
+					x if x == TypeId::of::<u32>() => FromStr::from_str(string).map(TaggedValue::U32).ok()?,
+					x if x == TypeId::of::<bool>() => FromStr::from_str(string).map(TaggedValue::Bool).ok()?,
+					x if x == TypeId::of::<Color>() => Color::from_rgba_str(string).map(TaggedValue::Color)?,
+					_ => return None,
+				};
+				Some(ty)
+			}
+			Type::Fn(_, output) => TaggedValue::from_primitive_string(string, output),
+			Type::Future(_) => None,
+		}
+	}
+
 	pub fn to_u32(&self) -> u32 {
 		match self {
 			TaggedValue::U32(x) => *x,

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

@@ -1,4 +1,4 @@
-use dyn_any::{DynAny, StaticType};
+use dyn_any::DynAny;
 use graphene_core::Color;
 use std::borrow::Cow;
 use std::fmt::Debug;

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

@@ -1,7 +1,7 @@
 use crate::document::{value, InlineRust};
 use crate::document::{NodeId, OriginalLocation};
 
-use dyn_any::DynAny;
+pub use graphene_core::registry::*;
 use graphene_core::*;
 
 use rustc_hash::FxHashMap;
@@ -10,88 +10,6 @@ use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
 use std::hash::Hash;
-use std::ops::Deref;
-use std::pin::Pin;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub type DynFuture<'n, T> = Pin<Box<dyn core::future::Future<Output = T> + 'n + Send>>;
-#[cfg(target_arch = "wasm32")]
-pub type DynFuture<'n, T> = Pin<Box<dyn core::future::Future<Output = T> + 'n>>;
-pub type LocalFuture<'n, T> = Pin<Box<dyn core::future::Future<Output = T> + 'n>>;
-#[cfg(not(target_arch = "wasm32"))]
-pub type Any<'n> = Box<dyn DynAny<'n> + 'n + Send>;
-#[cfg(target_arch = "wasm32")]
-pub type Any<'n> = Box<dyn DynAny<'n> + 'n>;
-pub type FutureAny<'n> = DynFuture<'n, Any<'n>>;
-// TODO: is this safe? This is assumed to be send+sync.
-#[cfg(not(target_arch = "wasm32"))]
-pub type TypeErasedNode<'n> = dyn for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + 'n + Send + Sync;
-#[cfg(target_arch = "wasm32")]
-pub type TypeErasedNode<'n> = dyn for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + 'n;
-pub type TypeErasedPinnedRef<'n> = Pin<&'n TypeErasedNode<'n>>;
-pub type TypeErasedRef<'n> = &'n TypeErasedNode<'n>;
-pub type TypeErasedBox<'n> = Box<TypeErasedNode<'n>>;
-pub type TypeErasedPinned<'n> = Pin<Box<TypeErasedNode<'n>>>;
-
-pub type SharedNodeContainer = std::sync::Arc<NodeContainer>;
-
-pub type NodeConstructor = fn(Vec<SharedNodeContainer>) -> DynFuture<'static, TypeErasedBox<'static>>;
-
-#[derive(Clone)]
-pub struct NodeContainer {
-	#[cfg(feature = "dealloc_nodes")]
-	pub node: *const TypeErasedNode<'static>,
-	#[cfg(not(feature = "dealloc_nodes"))]
-	pub node: TypeErasedRef<'static>,
-}
-
-impl Deref for NodeContainer {
-	type Target = TypeErasedNode<'static>;
-
-	#[cfg(feature = "dealloc_nodes")]
-	fn deref(&self) -> &Self::Target {
-		unsafe { &*(self.node) }
-		#[cfg(not(feature = "dealloc_nodes"))]
-		self.node
-	}
-	#[cfg(not(feature = "dealloc_nodes"))]
-	fn deref(&self) -> &Self::Target {
-		self.node
-	}
-}
-
-/// #Safety
-/// Marks NodeContainer as Sync. This disallows the use of threadlocal storage for nodes as this would invalidate references to them.
-// TODO: implement this on a higher level wrapper to avoid misuse
-#[cfg(feature = "dealloc_nodes")]
-unsafe impl Send for NodeContainer {}
-#[cfg(feature = "dealloc_nodes")]
-unsafe impl Sync for NodeContainer {}
-
-#[cfg(feature = "dealloc_nodes")]
-impl Drop for NodeContainer {
-	fn drop(&mut self) {
-		unsafe { self.dealloc_unchecked() }
-	}
-}
-
-impl core::fmt::Debug for NodeContainer {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.debug_struct("NodeContainer").finish()
-	}
-}
-
-impl NodeContainer {
-	pub fn new(node: TypeErasedBox<'static>) -> SharedNodeContainer {
-		let node = Box::leak(node);
-		Self { node }.into()
-	}
-
-	#[cfg(feature = "dealloc_nodes")]
-	unsafe fn dealloc_unchecked(&mut self) {
-		std::mem::drop(Box::from_raw(self.node as *mut TypeErasedNode));
-	}
-}
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Default, PartialEq, Clone, Hash, Eq)]
@@ -487,7 +405,7 @@ impl ProtoNetwork {
 				self.nodes.push((
 					compose_node_id,
 					ProtoNode {
-						identifier: ProtoNodeIdentifier::new("graphene_core::structural::ComposeNode<_, _, _>"),
+						identifier: ProtoNodeIdentifier::new("graphene_core::structural::ComposeNode"),
 						construction_args: ConstructionArgs::Nodes(vec![(input_node_id, false), (node_id, true)]),
 						input,
 						original_location: OriginalLocation { path, ..Default::default() },
@@ -689,7 +607,7 @@ impl core::fmt::Debug for GraphError {
 pub type GraphErrors = Vec<GraphError>;
 
 /// The `TypingContext` is used to store the types of the nodes indexed by their stable node id.
-#[derive(Default, Clone)]
+#[derive(Default, Clone, dyn_any::DynAny)]
 pub struct TypingContext {
 	lookup: Cow<'static, HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeConstructor>>>,
 	inferred: HashMap<NodeId, NodeIOTypes>,
@@ -855,6 +773,7 @@ impl TypingContext {
 				Err(vec![GraphError::new(node, GraphErrorType::InvalidImplementations { parameters, error_inputs })])
 			}
 			[(org_nio, output)] => {
+				// TODO: Fix unsoundness caused by generic parameters not getting cleaned up
 				let node_io = NodeIOTypes::new(input, (*output).clone(), parameters);
 
 				// Save the inferred type
@@ -862,6 +781,25 @@ impl TypingContext {
 				self.constructor.insert(node_id, impls[org_nio]);
 				Ok(node_io)
 			}
+			// If two types are available and one of them accepts () an input, always choose that one
+			[first, second] => {
+				if first.0.input != second.0.input {
+					for (org_nio, output) in [first, second] {
+						if org_nio.input != concrete!(()) {
+							continue;
+						}
+						let node_io = NodeIOTypes::new(input, (*output).clone(), parameters);
+
+						// Save the inferred type
+						self.inferred.insert(node_id, node_io.clone());
+						self.constructor.insert(node_id, impls[org_nio]);
+						return Ok(node_io);
+					}
+				}
+				let parameters = [&input].into_iter().chain(&parameters).map(|t| t.to_string()).collect::<Vec<_>>().join(", ");
+				let valid = valid_output_types.into_iter().cloned().collect();
+				Err(vec![GraphError::new(node, GraphErrorType::MultipleImplementations { parameters, valid })])
+			}
 
 			_ => {
 				let parameters = [&input].into_iter().chain(&parameters).map(|t| t.to_string()).collect::<Vec<_>>().join(", ");
@@ -977,9 +915,9 @@ mod test {
 				NodeId(12083027370457564588),
 				NodeId(10127202135369428481),
 				NodeId(3781642984881236270),
-				NodeId(9447822059040146367),
-				NodeId(15916837829094140504),
-				NodeId(1758919868423328454)
+				NodeId(12160249450476233602),
+				NodeId(17962581471057044127),
+				NodeId(7906594012485169109)
 			]
 		);
 	}