Deprecate automatic composition (#3088)

* Make manual_compositon non optional and rename to call_argument

* Fix clippy warnings

* Remove automatic composition compiler infrastructure

* Implement document migration

* Fix tests

* Fix compilation on web

* Fix doble number test

* Remove extra parens

* Cleanup

* Update demo artwork

* Remove last compose node mention

* Remove last mention of manual composition

node-graph/interpreted-executor/src/dynamic_executor.rs

@@ -393,7 +393,7 @@ impl BorrowTree {
 			}
 			ConstructionArgs::Inline(_) => unimplemented!("Inline nodes are not supported yet"),
 			ConstructionArgs::Nodes(ids) => {
-				let ids: Vec<_> = ids.iter().map(|id| *id).collect();
+				let ids = ids.to_vec();
 				let construction_nodes = self.node_deps(&ids);
 				let constructor = typing_context.constructor(id).ok_or_else(|| vec![GraphError::new(&proto_node, GraphErrorType::NoConstructor)])?;
 				let node = constructor(construction_nodes).await;

node-graph/interpreted-executor/src/lib.rs

@@ -19,7 +19,8 @@ mod tests {
 				(
 					NodeId(0),
 					DocumentNode {
-						inputs: vec![NodeInput::network(concrete!(u32), 0)],
+						inputs: vec![],
+						call_argument: concrete!(u32),
 						implementation: DocumentNodeImplementation::ProtoNode(ops::identity::IDENTIFIER),
 						..Default::default()
 					},

node-graph/interpreted-executor/src/node_registry.rs

@@ -8,15 +8,15 @@ use graphene_core::raster::*;
 #[cfg(feature = "gpu")]
 use graphene_core::raster_types::GPU;
 use graphene_core::raster_types::{CPU, Raster};
-use graphene_core::{Artboard, concrete, generic};
-use graphene_core::{Cow, ProtoNodeIdentifier, Type};
+use graphene_core::{Artboard, concrete};
+use graphene_core::{Cow, ProtoNodeIdentifier};
 use graphene_core::{NodeIO, NodeIOTypes};
 use graphene_core::{fn_type_fut, future};
 use graphene_std::Context;
 use graphene_std::Graphic;
 #[cfg(feature = "gpu")]
 use graphene_std::any::DowncastBothNode;
-use graphene_std::any::{ComposeTypeErased, DynAnyNode, IntoTypeErasedNode};
+use graphene_std::any::DynAnyNode;
 use graphene_std::application_io::{ImageTexture, SurfaceFrame};
 use graphene_std::brush::brush_cache::BrushCache;
 use graphene_std::brush::brush_stroke::BrushStroke;
@@ -161,25 +161,6 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => WgpuSurface]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Option<WgpuSurface>]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => ImageTexture]),
-		// ============
-		// COMPOSE NODE
-		// ============
-		(
-			ProtoNodeIdentifier::new("graphene_core::structural::ComposeNode"),
-			|args| {
-				Box::pin(async move {
-					let node = ComposeTypeErased::new(args[0].clone(), args[1].clone());
-					node.into_type_erased()
-				})
-			},
-			// This is how we can generically define composition of two nodes.
-			// See further details in the code definition for the `struct ComposeNode<First, Second, I> { ... }` struct.
-			NodeIOTypes::new(
-				generic!(T),
-				generic!(U),
-				vec![Type::Fn(Box::new(generic!(T)), Box::new(generic!(V))), Type::Fn(Box::new(generic!(V)), Box::new(generic!(U)))],
-			),
-		),
 		// =======================
 		// CREATE GPU SURFACE NODE
 		// =======================

node-graph/interpreted-executor/src/util.rs

@@ -30,20 +30,20 @@ pub fn wrap_network_in_scope(mut network: NodeNetwork, editor_api: Arc<WasmEdito
 			nodes: [
 				DocumentNode {
 					inputs: vec![NodeInput::scope("editor-api")],
-					manual_composition: Some(concrete!(Context)),
+					call_argument: concrete!(Context),
 					implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("wgpu_executor::CreateGpuSurfaceNode")),
 					skip_deduplication: true,
 					..Default::default()
 				},
 				DocumentNode {
-					manual_composition: Some(concrete!(Context)),
+					call_argument: concrete!(Context),
 					inputs: vec![NodeInput::node(NodeId(0), 0)],
 					implementation: DocumentNodeImplementation::ProtoNode(graphene_core::memo::memo::IDENTIFIER),
 					..Default::default()
 				},
 				// TODO: Add conversion step
 				DocumentNode {
-					manual_composition: Some(concrete!(graphene_std::application_io::RenderConfig)),
+					call_argument: concrete!(graphene_std::application_io::RenderConfig),
 					inputs: vec![
 						NodeInput::scope("editor-api"),
 						NodeInput::network(graphene_core::Type::Fn(Box::new(concrete!(Context)), Box::new(generic!(T))), 0),