Sweep the data-flow wire and edge wording to input and source

node-graph/node-macro/src/codegen/classify.rs

@@ -131,7 +131,7 @@ pub(crate) fn lazy_read_fields<'a>(regular_fields: &[&'a ParsedField]) -> Vec<(u
 }
 
 /// The indices (into the unit-skipped regular fields) of value inputs whose
-/// reads resolve against their own wire rather than the carrier's.
+/// reads resolve against their own input rather than the carrier's.
 pub(crate) fn reading_secondary_indices(regular_fields: &[&ParsedField], skips_carrier: bool) -> Vec<usize> {
 	regular_fields
 		.iter()
@@ -177,7 +177,7 @@ pub(crate) fn substitute_ident_types(ty: &Type, assignments: &[(Ident, Type)]) -
 }
 
 /// Replaces the routing generic in a derive-routing kernel's return type with
-/// the routing record value, since the kernel's edges rebind to '__record.
+/// the routing record value, since the kernel's inputs rebind to '__record.
 pub(crate) fn substitute_routing_record(output: &Type, generic: &Ident, core_types: &TokenStream2) -> Type {
 	struct Subst<'a> {
 		generic: &'a Ident,
@@ -295,7 +295,7 @@ pub(crate) fn record_shape(parsed: &ParsedNodeFn) -> Option<RecordShape> {
 		return None;
 	}
 	// An async source's slot stores the kernel's plain tuple; the per-eval lift
-	// writes it through the claim, and the reads have no wire to bind against.
+	// writes it through the claim, and the reads have no input to bind against.
 	if source && (has_reads || writes.is_none()) {
 		return None;
 	}
@@ -306,7 +306,7 @@ pub(crate) fn record_shape(parsed: &ParsedNodeFn) -> Option<RecordShape> {
 	// A first-field lazy carrier: the kernel evaluates the derived content
 	// itself and returns its opaque row token beside the write set.
 	let lazy_carrier = matches!(&carrier_field.ty, ParsedFieldType::Node(_));
-	// Lazy secondaries are consumed as plain elements; raw record edges and
+	// Lazy secondaries are consumed as plain elements; raw record inputs and
 	// ranked outputs have no element binding here.
 	let unsupported_lazy_secondary = |field: &ParsedField| match &field.ty {
 		ParsedFieldType::Node(NodeParsedField { output_type, .. }) => is_served(output_type) || crate::codegen::ir::strip_ilist(output_type).1 > 0 || !field.attribute_reads.is_empty(),
@@ -423,7 +423,7 @@ pub(crate) fn flip_carrier(parsed: &ParsedNodeFn) -> bool {
 	!(async_kernel && lend.is_some())
 }
 
-/// Whether a plain node's lowering flips onto record wires: sync,
+/// Whether a plain node's lowering flips onto record inputs: sync,
 /// fully-concrete value-input nodes in this cut; batch, shader, async, lend,
 /// lazy, and generic nodes keep the plain lowering until their record forms
 /// land.
@@ -467,7 +467,7 @@ pub(crate) fn record_flip(parsed: &ParsedNodeFn) -> bool {
 					return false;
 				}
 			}
-			// A named lifetime is the serving lifetime: wire types substitute
+			// A named lifetime is the serving lifetime: input types substitute
 			// its erased projection in registry and layout contexts.
 			GenericParam::Lifetime(_) => {}
 			GenericParam::Const(_) => return false,
@@ -520,7 +520,7 @@ pub(crate) fn is_served(ty: &Type) -> bool {
 }
 
 /// Whether a kernel operates on whole records: it serves through the claim it
-/// was handed, receives raw record edges paired with the node's layout, and
+/// was handed, receives raw record inputs paired with the node's layout, and
 /// takes on the record APIs' unsafe contracts itself.
 pub(crate) fn record_opaque(parsed: &ParsedNodeFn) -> bool {
 	is_served(&slot_value_type(&parsed.output_type))
@@ -723,7 +723,7 @@ pub(crate) fn type_disqualifies(ty: &Type) -> bool {
 	visitor.found
 }
 
-/// The wire type with every named serving lifetime replaced: `'static` for
+/// The input type with every named serving lifetime replaced: `'static` for
 /// registry, layout, and declaration contexts (the erased projection shares
 /// its type id and layout), `'_` for eval bindings, where inference recovers
 /// the serving lifetime.
@@ -749,7 +749,7 @@ pub(crate) fn substitute_lifetimes(ty: &Type, replacement: &str) -> Type {
 	ty
 }
 
-/// The serving lifetime a wire type names, so a materialized binding can tie
+/// The serving lifetime an input type names, so a materialized binding can tie
 /// the list view to the element's own region.
 pub(crate) fn named_serving_lifetime(ty: &Type) -> Option<Lifetime> {
 	struct Find {

node-graph/node-macro/src/codegen/entries.rs

@@ -15,7 +15,7 @@ pub(crate) fn entries_tokens(parsed: &ParsedNodeFn, struct_name: &Ident, data_fi
 	}
 }
 
-/// The registry rows of a flipped plain node: every wire is a record wire,
+/// The registry rows of a flipped plain node: every input is a record input,
 /// inputs resolve their layouts off the claimed handles, and the output is an
 /// element-only record of the kernel's return type.
 fn flip_entries_tokens(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields: &[&ParsedField]) -> TokenStream2 {
@@ -179,20 +179,20 @@ fn flip_entries_tokens(parsed: &ParsedNodeFn, struct_name: &Ident, regular_field
 	}
 }
 
-/// Which record wire an input claims and how its value is recovered. Base slots
-/// are the record edges whose layouts form the output; value slots are record
-/// edges read for their layout.
+/// Which record an input claims and how its value is recovered. Base slots
+/// are the record inputs whose layouts form the output; value slots are record
+/// inputs read for their layout.
 enum SlotKind {
-	/// A generic record edge whose element is only known at runtime; the runtime
+	/// A generic record input whose element is only known at runtime; the runtime
 	/// type is captured for the output wrap or the union.
 	BaseGeneric(String),
 	/// A concrete record carrier read for its layout.
 	BaseConcrete(Type),
-	/// A concrete record edge read for its layout only.
+	/// A concrete record input read for its layout only.
 	Value(Type),
-	/// A record edge whose element extracts to the node's plain value input.
+	/// A record input whose element extracts to the node's plain value input.
 	Extracted(Type),
-	/// A ranked record edge consumed whole; no layout rides to the constructor.
+	/// A ranked record input consumed whole; no layout rides to the constructor.
 	Ranked(Type),
 }
 
@@ -203,7 +203,7 @@ impl SlotKind {
 }
 
 /// The single registry row shared by record-io, routing, and opaque nodes: one
-/// instance covers the wire, each input's edge type and downcast follow its
+/// instance covers the input, each input's type and downcast follow its
 /// slot, and the output layout folds from the base slots.
 fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields: &[&ParsedField]) -> TokenStream2 {
 	use crate::codegen::ir;
@@ -212,8 +212,8 @@ fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields
 	let core_types = quote!(gcore);
 	let lend = |field: &ParsedField| matches!(&field.ty, ParsedFieldType::Regular(RegularParsedField { lend: Some(_), .. }));
 
-	// A subject is its record edge (concrete carrier or erased generic); a
-	// non-subject value rides a record edge when it reads its layout.
+	// A subject is its record input (concrete carrier or erased generic); a
+	// non-subject value rides a record input when it reads its layout.
 	let slots: Option<Vec<SlotKind>> = regular_fields
 		.iter()
 		.enumerate()
@@ -228,7 +228,7 @@ fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields
 			}
 			match &field.ty {
 				// An element-consuming lazy secondary of a record node rides a
-				// record edge with a layout slot, like a reading secondary.
+				// record input with a layout slot, like a reading secondary.
 				ParsedFieldType::Node(NodeParsedField { output_type, .. })
 					if matches!(ir::node_kind(&node), ir::NodeKind::RecordIo) && matches!(ir::lazy_binding(&node, index), ir::LazyBinding::Element) =>
 				{
@@ -241,8 +241,8 @@ fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields
 				ParsedFieldType::Regular(RegularParsedField { ty, .. }) => match ir::value_binding(&node, index) {
 					ir::ValueBinding::Materialized => Some(SlotKind::Ranked(ty.clone())),
 					ir::ValueBinding::ReadingSecondary | ir::ValueBinding::RecordElement => Some(SlotKind::Value(ty.clone())),
-					// One wire kind: a record node's plain value still rides a
-					// record edge, extracted to its element at construction.
+					// One input kind: a record node's plain value still rides a
+					// record input, extracted to its element at construction.
 					_ if matches!(ir::node_kind(&node), ir::NodeKind::RecordIo) => Some(SlotKind::Extracted(ty.clone())),
 					_ => {
 						emit_error!(field.pat_ident.span(), "plain (non-record) io is unsupported: this value input needs a record edge");
@@ -359,7 +359,7 @@ fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields
 						let #layout = #handle.layout().clone();
 						let #name = #handle.downcast_record::<#value_ty>()?;
 					},
-					// The node reads the element off the edge's own layout, so
+					// The node reads the element off the input's own layout, so
 					// neither slot rides a layout to the constructor.
 					SlotKind::Extracted(value_ty) | SlotKind::Ranked(value_ty) => quote! {
 						let #name = inputs.next().unwrap().downcast_record::<#value_ty>()?;
@@ -382,7 +382,7 @@ fn single_row_entries(parsed: &ParsedNodeFn, struct_name: &Ident, regular_fields
 				quote!(Some(#meta))
 			};
 
-			// The output wire and node wrap follow the output element: a concrete (or
+			// The output type and node wrap follow the output element: a concrete (or
 			// row-assigned) element is a typed record; a generic or opaque element is
 			// an erased record carrying the first base slot's runtime type.
 			let output_element = match &node.output.shape.element {

node-graph/node-macro/src/codegen/ir.rs

@@ -388,13 +388,13 @@ pub(crate) enum LazyBinding {
 }
 
 impl ValueBinding {
-	/// Copies an element out of a record edge, so the frame is reclaimed after.
+	/// Copies an element out of a record input, so the frame is reclaimed after.
 	pub(crate) fn reads_out(&self) -> bool {
 		matches!(self, ValueBinding::ReadingSecondary | ValueBinding::RecordElement | ValueBinding::Plain)
 	}
 }
 
-/// A record node's lazy inputs consumed as plain elements: their record edges
+/// A record node's lazy inputs consumed as plain elements: their record inputs
 /// need a layout slot at wiring, like the reading secondaries.
 pub(crate) fn element_lazy_indices(regular_fields: &[&ParsedField], node: &Node) -> Vec<usize> {
 	if !matches!(node_kind(node), NodeKind::RecordIo) {
@@ -454,7 +454,7 @@ fn has_attr_io(node: &Node) -> bool {
 pub(crate) fn materialized_levels(node: &Node, index: usize) -> u8 {
 	let input = &node.inputs[index];
 	// An eager input's declared `IList` nesting IS its materialization count,
-	// independent of the rank delta; lazy edges never materialize.
+	// independent of the rank delta; lazy inputs never materialize.
 	match input.evaluation {
 		Evaluation::Eager => input.shape.depth,
 		Evaluation::Lazy => 0,