remove inline

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

@@ -143,10 +143,6 @@ impl DocumentNode {
 
 		let mut construction_args = ConstructionArgs::Nodes(vec![]);
 
-		// If we have one input of the type inline, set it as the construction args
-		if let &[NodeInput::Inline(ref inline)] = self.inputs.as_slice() {
-			construction_args = ConstructionArgs::Inline(inline.clone());
-		}
 		// If we have one input of the type inline, set it as the construction args
 		if let &[NodeInput::Value { ref tagged_value, .. }] = self.inputs.as_slice() {
 			construction_args = ConstructionArgs::Value(tagged_value.clone());
@@ -188,22 +184,6 @@ pub enum NodeInput {
 
 	/// Input that is extracted from the parent scopes the node resides in. The string argument is the key.
 	Reflection(DocumentNodeMetadata),
-
-	/// A Rust source code string. Allows us to insert literal Rust code. Only used for GPU compilation.
-	/// We can use this whenever we spin up Rustc. Sort of like inline assembly, but because our language is Rust, it acts as inline Rust.
-	Inline(InlineRust),
-}
-
-#[derive(Debug, Clone, PartialEq, Hash, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct InlineRust {
-	pub expr: String,
-	pub ty: Type,
-}
-
-impl InlineRust {
-	pub fn new(expr: String, ty: Type) -> Self {
-		Self { expr, ty }
-	}
 }
 
 #[derive(Debug, Clone, PartialEq, Hash, DynAny, serde::Serialize, serde::Deserialize)]
@@ -240,7 +220,6 @@ impl NodeInput {
 			NodeInput::Node { .. } => true,
 			NodeInput::Value { exposed, .. } => *exposed,
 			NodeInput::Import { .. } => true,
-			NodeInput::Inline(_) => false,
 			NodeInput::Scope(_) => false,
 			NodeInput::Reflection(_) => false,
 		}
@@ -251,7 +230,6 @@ impl NodeInput {
 			NodeInput::Node { .. } => unreachable!("ty() called on NodeInput::Node"),
 			NodeInput::Value { tagged_value, .. } => tagged_value.ty(),
 			NodeInput::Import { import_type, .. } => import_type.clone(),
-			NodeInput::Inline(_) => panic!("ty() called on NodeInput::Inline"),
 			NodeInput::Scope(_) => panic!("ty() called on NodeInput::Scope"),
 			NodeInput::Reflection(_) => concrete!(Metadata),
 		}
@@ -846,7 +824,6 @@ impl NodeNetwork {
 							*import_index = parent_input_index;
 						}
 						NodeInput::Value { .. } => unreachable!("Value inputs should have been replaced with value nodes"),
-						NodeInput::Inline(_) => (),
 						NodeInput::Scope(ref key) => {
 							let (import_id, _ty) = self.scope_injections.get(key.as_ref()).expect("Tried to import a non existent key from scope");
 							// TODO use correct output index

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

@@ -1,5 +1,5 @@
+use crate::document::value;
 use crate::document::value::TaggedValue;
-use crate::document::{InlineRust, value};
 use crate::document::{NodeId, OriginalLocation};
 pub use graphene_core::registry::*;
 use graphene_core::*;
@@ -51,10 +51,6 @@ impl core::fmt::Display for ProtoNetwork {
 						write_node(f, network, *id, indent + 1)?;
 					}
 				}
-				ConstructionArgs::Inline(inline) => {
-					f.write_str(&"\t".repeat(indent + 1))?;
-					f.write_fmt(format_args!("Inline construction argument: {inline:?}"))?
-				}
 			}
 			f.write_str(&"\t".repeat(indent))?;
 			f.write_str("}\n")?;
@@ -75,8 +71,6 @@ pub enum ConstructionArgs {
 	/// The bool indicates whether to treat the node as lambda node.
 	// TODO: use a struct for clearer naming.
 	Nodes(Vec<NodeId>),
-	/// Used for GPU computation to work around the limitations of rust-gpu.
-	Inline(InlineRust),
 }
 
 impl Eq for ConstructionArgs {}
@@ -109,7 +103,6 @@ impl Hash for ConstructionArgs {
 				}
 			}
 			Self::Value(value) => value.hash(state),
-			Self::Inline(inline) => inline.hash(state),
 		}
 	}
 }
@@ -119,7 +112,6 @@ impl ConstructionArgs {
 		match self {
 			ConstructionArgs::Nodes(nodes) => nodes.iter().map(|n| format!("n{:0x}", n.0)).collect(),
 			ConstructionArgs::Value(value) => vec![value.to_primitive_string()],
-			ConstructionArgs::Inline(inline) => vec![inline.expr.clone()],
 		}
 	}
 }
@@ -376,7 +368,6 @@ impl ProtoNetwork {
 			// We pretend like we have already placed context modification nodes after ourselves because value nodes don't need to be cached
 			ConstructionArgs::Value(_) => return (context_features.extract, Some(id)),
 			ConstructionArgs::Nodes(items) => items.clone(),
-			ConstructionArgs::Inline(_) => return (context_features.extract, Some(id)),
 		};
 
 		// Compute the dependencies for each branch and combine all of them
@@ -686,7 +677,6 @@ impl TypingContext {
 						.map(|node| node.ty())
 				})
 				.collect::<Result<Vec<Type>, GraphErrors>>()?,
-			ConstructionArgs::Inline(ref inline) => vec![inline.ty.clone()],
 		};
 
 		// Get the node input type from the proto node declaration

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

@@ -391,7 +391,6 @@ impl BorrowTree {
 				};
 				self.store_node(node, id, path.into());
 			}
-			ConstructionArgs::Inline(_) => unimplemented!("Inline nodes are not supported yet"),
 			ConstructionArgs::Nodes(ids) => {
 				let ids = ids.to_vec();
 				let construction_nodes = self.node_deps(&ids);