Require a node registry to compile so the layout pass always runs

Cargo.lock

@@ -2008,6 +2008,7 @@ dependencies = [
  "graphene-hash",
  "graphic-types",
  "gungraun",
+ "interpreted-executor",
  "js-sys",
  "log",
  "mmap-io",

document/graph-storage/src/tests/round_trip.rs

@@ -14,7 +14,7 @@ use crate::{NetworkId, NodeMetadataSource, PeerId, Position, Registry};
 /// Test networks with Import inputs will fail compilation (which is expected).
 fn verify_network_compiles(network: &NodeNetwork) -> Result<(), String> {
 	let compiler = Compiler {};
-	compiler.compile_single(network.clone(), None).map_err(|e| format!("Compilation failed: {:?}", e))?;
+	compiler.compile_single(network.clone(), &graph_craft::proto::Registry::new()).map_err(|e| format!("Compilation failed: {:?}", e))?;
 	Ok(())
 }
 

editor/src/node_graph_executor/runtime.rs

@@ -438,7 +438,7 @@ impl NodeRuntime {
 		assert_eq!(scoped_network.exports.len(), 1, "Graph with multiple outputs not yet handled");
 
 		let c = Compiler {};
-		let proto_network = match c.compile_single(scoped_network, None) {
+		let proto_network = match c.compile_single(scoped_network, &interpreted_executor::node_registry::NODE_REGISTRY) {
 			Ok(network) => network,
 			Err(e) => return Err((ResolvedDocumentNodeTypesDelta::default(), e)),
 		};

node-graph/graph-craft/Cargo.toml

@@ -74,6 +74,7 @@ mmap-io = { workspace = true }
 [dev-dependencies]
 # Workspace dependencies
 graph-craft = { workspace = true, features = ["loading"] }
+interpreted-executor = { workspace = true }
 pretty_assertions = { workspace = true }
 criterion = { workspace = true }
 gungraun = { workspace = true }

node-graph/graph-craft/benches/compile_demo_art_criterion.rs

@@ -6,10 +6,11 @@ use graph_craft::util::DEMO_ART;
 fn compile_to_proto(c: &mut Criterion) {
 	use graph_craft::util::{compile, load_from_name};
 	let mut c = c.benchmark_group("Compile Network cold");
+	let registry = &interpreted_executor::node_registry::NODE_REGISTRY;
 
 	for name in DEMO_ART {
 		let network = load_from_name(name);
-		c.bench_function(name, |b| b.iter_batched(|| network.clone(), |network| compile(black_box(network)), criterion::BatchSize::SmallInput));
+		c.bench_function(name, |b| b.iter_batched(|| network.clone(), |network| compile(black_box(network), registry), criterion::BatchSize::SmallInput));
 	}
 }
 

node-graph/graph-craft/benches/compile_demo_art_gungraun.rs

@@ -5,7 +5,7 @@ use gungraun::prelude::*;
 #[library_benchmark]
 #[benches::with_setup(args = ["isometric-fountain", "painted-dreams", "procedural-string-lights", "parametric-dunescape", "red-dress", "valley-of-spires"], setup = load_from_name)]
 pub fn compile_to_proto(_input: NodeNetwork) {
-	std::hint::black_box(compile(_input));
+	std::hint::black_box(compile(_input, &interpreted_executor::node_registry::NODE_REGISTRY));
 }
 
 library_benchmark_group!(name = compile_group; benchmarks = compile_to_proto);

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

@@ -5,7 +5,7 @@ use std::error::Error;
 pub struct Compiler {}
 
 impl Compiler {
-	pub fn compile<'r>(&self, mut network: NodeNetwork, registry: Option<&'r Registry>) -> impl Iterator<Item = Result<ProtoNetwork, String>> + 'r {
+	pub fn compile<'r>(&self, mut network: NodeNetwork, registry: &'r Registry) -> impl Iterator<Item = Result<ProtoNetwork, String>> + 'r {
 		network.resolve_scope_inputs();
 		network.generate_node_paths(&[]);
 		let node_ids = network.nodes.keys().copied().collect::<Vec<_>>();
@@ -19,15 +19,13 @@ impl Compiler {
 
 		proto_networks.map(move |mut proto_network| {
 			proto_network.insert_context_nullification_nodes()?;
-			if let Some(registry) = registry {
+			let _ = proto_network.resolve_types(registry);
-				let _ = proto_network.resolve_types(registry);
+			proto_network.compute_layouts();
-				proto_network.compute_layouts();
-			}
 			proto_network.generate_stable_node_ids();
 			Ok(proto_network)
 		})
 	}
-	pub fn compile_single(&self, network: NodeNetwork, registry: Option<&Registry>) -> Result<ProtoNetwork, String> {
+	pub fn compile_single(&self, network: NodeNetwork, registry: &Registry) -> Result<ProtoNetwork, String> {
 		assert_eq!(network.exports.len(), 1, "Graph with multiple outputs not yet handled");
 		let Some(proto_network) = self.compile(network, registry).next() else {
 			return Err("Failed to convert graph into proto graph".to_string());

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

@@ -1,6 +1,6 @@
 use crate::document::NodeNetwork;
 use crate::graphene_compiler::Compiler;
-use crate::proto::ProtoNetwork;
+use crate::proto::{ProtoNetwork, Registry};
 
 pub fn load_network(document_string: &str) -> NodeNetwork {
 	let document: serde_json::Value = serde_json::from_str(document_string).expect("Failed to parse document");
@@ -8,9 +8,9 @@ pub fn load_network(document_string: &str) -> NodeNetwork {
 	serde_json::from_str::<NodeNetwork>(&document).expect("Failed to parse document")
 }
 
-pub fn compile(network: NodeNetwork) -> ProtoNetwork {
+pub fn compile(network: NodeNetwork, registry: &Registry) -> ProtoNetwork {
 	let compiler = Compiler {};
-	compiler.compile_single(network, None).unwrap()
+	compiler.compile_single(network, registry).unwrap()
 }
 
 pub fn load_from_name(name: &str) -> NodeNetwork {

node-graph/graphene-cli/src/main.rs

@@ -314,7 +314,7 @@ fn compile_graph(network: NodeNetwork, editor_api: Arc<PlatformEditorApi>, gdd:
 	}
 
 	let compiler = Compiler {};
-	compiler.compile_single(network, Some(&interpreted_executor::node_registry::NODE_REGISTRY)).map_err(|x| x.into())
+	compiler.compile_single(network, &interpreted_executor::node_registry::NODE_REGISTRY).map_err(|x| x.into())
 }
 
 fn create_executor(proto_network: ProtoNetwork, runtime: Arc<DynGraphRuntime>) -> Result<DynamicExecutor, Box<dyn Error>> {

node-graph/interpreted-executor/benches/benchmark_util.rs

@@ -12,7 +12,7 @@ pub fn setup_network(name: &str) -> (DynamicExecutor, ProtoNetwork) {
 	let mut network = wrap_network_in_scope(network, editor_api);
 	let preprocessor = preprocessor::Preprocessor::new();
 	preprocessor.preprocess(&mut network, &|_| None).unwrap();
-	let proto_network = compile(network);
+	let proto_network = compile(network, &interpreted_executor::node_registry::NODE_REGISTRY);
 	let executor = DynamicExecutor::new(proto_network.clone()).unwrap();
 	(executor, proto_network)
 }

node-graph/interpreted-executor/benches/run_demo_art_criterion.rs

@@ -8,7 +8,7 @@ use interpreted_executor::dynamic_executor::DynamicExecutor;
 
 fn update_executor<M: Measurement>(name: &str, c: &mut BenchmarkGroup<M>) {
 	let network = load_from_name(name);
-	let proto_network = compile(network);
+	let proto_network = compile(network, &interpreted_executor::node_registry::NODE_REGISTRY);
 
 	c.bench_function(name, |b| {
 		b.iter_batched(
@@ -28,7 +28,7 @@ fn update_executor_demo(c: &mut Criterion) {
 
 fn run_once<M: Measurement>(name: &str, c: &mut BenchmarkGroup<M>) {
 	let network = load_from_name(name);
-	let proto_network = compile(network);
+	let proto_network = compile(network, &interpreted_executor::node_registry::NODE_REGISTRY);
 
 	let executor = DynamicExecutor::new(proto_network).unwrap();
 	let footprint = Footprint::default();

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

@@ -44,7 +44,7 @@ mod tests {
 		use graph_craft::graphene_compiler::Compiler;
 
 		let compiler = Compiler {};
-		let protograph = compiler.compile_single(network, Some(&crate::node_registry::NODE_REGISTRY)).expect("Graph should be generated");
+		let protograph = compiler.compile_single(network, &crate::node_registry::NODE_REGISTRY).expect("Graph should be generated");
 
 		let _exec = DynamicExecutor::new(protograph).map(|_e| panic!("The network should not type check ")).unwrap_err();
 	}