Make the dynamic node graph execution asynchronous (#1218)

* Make node graph execution async

Make node macro generate async node implementations

Start propagating async through the node system

Async checkpoint

Make Any<'i> Send + Sync

Determine node io type using panic node

Fix types for raster_node macro

Finish porting node registry?

Fix lifetime errors

Remove Send + Sync requirements and start making node construction async

Async MVP

Fix tests

Clippy fix

* Fix nodes

* Simplify lifetims for node macro + make node macro more modular

* Reenable more nodes

* Fix pasting images

* Remove http test from brush node

* Fix output type for cache node

* Fix types for let scope

* Fix formatting

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

@@ -295,7 +295,7 @@ impl NodeNetwork {
 		self.previous_outputs.as_ref().unwrap_or(&self.outputs)
 	}
 
-	pub fn input_types<'a>(&'a self) -> impl Iterator<Item = Type> + 'a {
+	pub fn input_types(&self) -> impl Iterator<Item = Type> + '_ {
 		self.inputs.iter().map(move |id| self.nodes[id].inputs.get(0).map(|i| i.ty()).unwrap_or(concrete!(())))
 	}
 

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

@@ -1,6 +1,7 @@
 use super::DocumentNode;
 use crate::executor::Any;
 pub use crate::imaginate_input::{ImaginateMaskStartingFill, ImaginateSamplingMethod, ImaginateStatus};
+use crate::proto::{Any as DAny, FutureAny};
 
 use graphene_core::raster::{BlendMode, LuminanceCalculation};
 use graphene_core::{Color, Node, Type};
@@ -305,11 +306,11 @@ impl<'a> TaggedValue {
 pub struct UpcastNode {
 	value: TaggedValue,
 }
-impl<'input> Node<'input, Box<dyn DynAny<'input> + 'input>> for UpcastNode {
-	type Output = Box<dyn DynAny<'input> + 'input>;
+impl<'input> Node<'input, DAny<'input>> for UpcastNode {
+	type Output = FutureAny<'input>;
 
-	fn eval(&'input self, _: Box<dyn DynAny<'input> + 'input>) -> Self::Output {
-		self.value.clone().to_any()
+	fn eval(&'input self, _: DAny<'input>) -> Self::Output {
+		Box::pin(async move { self.value.clone().to_any() })
 	}
 }
 impl UpcastNode {

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

@@ -3,7 +3,7 @@ use std::error::Error;
 use dyn_any::DynAny;
 
 use crate::document::NodeNetwork;
-use crate::proto::ProtoNetwork;
+use crate::proto::{LocalFuture, ProtoNetwork};
 
 pub struct Compiler {}
 
@@ -37,5 +37,5 @@ impl Compiler {
 pub type Any<'a> = Box<dyn DynAny<'a> + 'a>;
 
 pub trait Executor {
-	fn execute<'a, 's: 'a>(&'s self, input: Any<'a>) -> Result<Any<'a>, Box<dyn Error>>;
+	fn execute<'a>(&'a self, input: Any<'a>) -> LocalFuture<Result<Any<'a>, Box<dyn Error>>>;
 }

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

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
+
 use std::hash::Hash;
 use xxhash_rust::xxh3::Xxh3;
 
@@ -11,12 +12,15 @@ use graphene_core::*;
 use serde::{Deserialize, Serialize};
 use std::pin::Pin;
 
+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>>;
 pub type Any<'n> = Box<dyn DynAny<'n> + 'n>;
-pub type TypeErasedNode<'n> = dyn for<'i> NodeIO<'i, Any<'i>, Output = Any<'i>> + 'n + Send + Sync;
-pub type TypeErasedPinnedRef<'n> = Pin<&'n (dyn for<'i> NodeIO<'i, Any<'i>, Output = Any<'i>> + 'n + Send + Sync)>;
-pub type TypeErasedPinned<'n> = Pin<Box<dyn for<'i> NodeIO<'i, Any<'i>, Output = Any<'i>> + 'n + Send + Sync>>;
+pub type FutureAny<'n> = DynFuture<'n, Any<'n>>;
+pub type TypeErasedNode<'n> = dyn for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + 'n;
+pub type TypeErasedPinnedRef<'n> = Pin<&'n (dyn for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + 'n)>;
+pub type TypeErasedPinned<'n> = Pin<Box<dyn for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + 'n>>;
 
-pub type NodeConstructor = for<'a> fn(Vec<TypeErasedPinnedRef<'static>>) -> TypeErasedPinned<'static>;
+pub type NodeConstructor = for<'a> fn(Vec<TypeErasedPinnedRef<'static>>) -> DynFuture<'static, TypeErasedPinned<'static>>;
 
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Default, PartialEq, Clone)]