fork/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2026-09-15 22:28:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Rename serve_edge to serve_input

Browse Source
This commit is contained in:
Dennis Kobert
2026-09-06 15:12:46 +00:00
parent 6961687172
commit 8f7d3936f8
15 changed files with 55 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
node-graph/graph-craft/src/document/value.rs
View File

@@ -366,20 +366,20 @@ macro_rules! tagged_value {
// =======================
if ty == core_types::registry::record_edge_type::<()>() {
let edge = handle.downcast_record::<()>().map_err(|e| format!("{e:?}"))?;
return Ok(core_types::record::serve_edge(&edge, ctx, frames).map(|_| TaggedValue::None));
return Ok(core_types::record::serve_input(&edge, ctx, frames).map(|_| TaggedValue::None));
}
$(
if ty == core_types::registry::record_edge_type::<$ty>() {
let layout = handle.layout().clone();
let edge = handle.downcast_record::<$ty>().map_err(|e| format!("{e:?}"))?;
return Ok(core_types::record::serve_edge(&edge, ctx, frames)
return Ok(core_types::record::serve_input(&edge, ctx, frames)
.map(|value| TaggedValue::$identifier(unsafe { core_types::record::read_element::<$ty>(layout.rec(&value)) })));
}
)*
if ty == core_types::registry::record_edge_type::<RenderOutput>() {
let layout = handle.layout().clone();
let edge = handle.downcast_record::<RenderOutput>().map_err(|e| format!("{e:?}"))?;
return Ok(core_types::record::serve_edge(&edge, ctx, frames)
return Ok(core_types::record::serve_input(&edge, ctx, frames)
.map(|value| TaggedValue::RenderOutput(unsafe { core_types::record::read_element::<RenderOutput>(layout.rec(&value)) })));
}
Err(format!("Cannot convert edge of type {ty} to TaggedValue"))

8
node-graph/interpreted-executor/src/dynamic_executor.rs
View File

@@ -219,7 +219,7 @@ impl DynamicExecutor {
_ => None,
}
} else {
match core_types::record::serve_edge(&edge, &ctx, &frames) {
match core_types::record::serve_input(&edge, &ctx, &frames) {
GPoll::Final(value) | GPoll::Partial(value) => {
let rec = layout.rec(&value);
// SAFETY: the serve produced one live record of the edge's layout.
@@ -697,7 +697,7 @@ mod test {
let scope = EvalScope::new(None, None, None, &generations, &arena);
let ctx = ContextImpl::root(&scope);
let frames = core_types::record::test_frames(layout.frame_bytes());
let GPoll::Final(value) = core_types::record::serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&edge, &ctx, &frames) else {
panic!("expected a final record");
};
assert_eq!(unsafe { core_types::record::read_element::<u32>(layout.rec(&value)) }, 2);
@@ -742,7 +742,7 @@ mod test {
let layout = handle.layout().clone();
let edge = handle.duplicate().downcast_record::<f64>().unwrap();
let frames = core_types::record::test_frames(executor.tree().stack_need());
let GPoll::Final(value) = core_types::record::serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&edge, &ctx, &frames) else {
panic!("the flipped clone must evaluate over record wires, got a non-final poll");
};
assert_eq!(unsafe { core_types::record::read_element::<f64>(layout.rec(&value)) }, 7.);
@@ -769,7 +769,7 @@ mod test {
let ctx = ContextImpl::root(&scope);
let edge = executor.tree().get(NodeId(2)).unwrap().downcast_record::<graphene_std::raster::color::Color>().unwrap();
let frames = core_types::record::test_frames(executor.tree().stack_need());
let result = core_types::record::serve_edge(&edge, &ctx, &frames);
let result = core_types::record::serve_input(&edge, &ctx, &frames);
// The empty raster level folds to an empty palette: past-end at lane 0.
assert!(
matches!(&result, GPoll::Error(error) if error.kind == core_types::gpoll::ErrorKind::PastEnd),

4
node-graph/libraries/core-types/src/node.rs
View File

@@ -631,7 +631,7 @@ mod tests {
use crate::arena::Arena;
use crate::context::ExtractArena;
use crate::record::{LiftedSource, serve_edge};
use crate::record::{LiftedSource, serve_input};
#[derive(Clone, Copy)]
struct TestInput<'a> {
@@ -676,7 +676,7 @@ mod tests {
let layout = Node::<TestInput>::layout(&node).clone();
let erased: Box<dyn Node<TestInput>> = Box::new(node);
let frames = crate::record::test_frames(1 << 12);
let GPoll::Final(value) = serve_edge(&*erased, &input, &frames) else {
let GPoll::Final(value) = serve_input(&*erased, &input, &frames) else {
panic!("the erased edge must serve a final record");
};
// SAFETY: the record was served at `layout`, whose element is the output.

4
node-graph/libraries/core-types/src/record/input.rs
View File

@@ -3,7 +3,7 @@
use super::access::{Rec, RecordValue, read_element};
use super::frames::Frames;
use super::layout::Layout;
use super::serve::{FrameClaim, Served, serve_edge};
use super::serve::{FrameClaim, Served, serve_input};
use crate::gpoll::GPoll;
use crate::node::Node;
@@ -513,6 +513,6 @@ impl<El: Clone + 'static, N> RecordExtract<El, N> {
// The element copies out by value, so the edge's claim dies with
// the scope.
let scope = frames.scope();
serve_edge(&self.edge, input, &scope).map(|value| unsafe { read_element::<El>(self.layout.rec(&value)) })
serve_input(&self.edge, input, &scope).map(|value| unsafe { read_element::<El>(self.layout.rec(&value)) })
}
}

2
node-graph/libraries/core-types/src/record/mod.rs
View File

@@ -32,5 +32,5 @@ pub use owned::{OwnedRecord, deepen_field_value, register_deep_element_clone, re
pub use promote::{Promotion, assert_promoted, register_element_promote, register_field_promote, register_retained_heap};
pub use route::{RecordSource, SourcePlan};
pub use run::{Group, GroupItem, RunBuilder, RunColumn, RunView};
pub use serve::{FrameClaim, MaterializedSpan, Served, SlotRun, serve_edge};
pub use serve::{FrameClaim, MaterializedSpan, Served, SlotRun, serve_input};
pub use testkit::{LiftedSource, ServedRecord, capture, test_frames};

4
node-graph/libraries/core-types/src/record/route.rs
View File

@@ -3,7 +3,7 @@
use super::access::{Rec, apply_plan};
use super::frames::Frames;
use super::layout::{Layout, copy_plan};
use super::serve::{FrameClaim, Served, serve_edge};
use super::serve::{FrameClaim, Served, serve_input};
use crate::attribute;
use crate::gpoll::GPoll;
use crate::node::Node;
@@ -97,7 +97,7 @@ where
let Some(plan) = &self.plan else {
return self.edge.serve(input, slot);
};
match serve_edge(&self.edge, input, &mut slot.frames().reborrow()) {
match serve_input(&self.edge, input, &mut slot.frames().reborrow()) {
GPoll::Final(value) => {
// SAFETY: the value came from this edge, so it carries the
// plan's source layout.

2
node-graph/libraries/core-types/src/record/serve.rs
View File

@@ -280,7 +280,7 @@ impl<'e> Served<'e> {
/// Claims `node`'s own frame from `frames` and serves through it: the
/// caller-side half of [`Node::serve`], for drivers that want the record
/// rather than the proof.
pub fn serve_edge<'e, C, N>(node: &N, input: &C, frames: &Frames<'e>) -> GPoll<RecordValue<'e>>
pub fn serve_input<'e, C, N>(node: &N, input: &C, frames: &Frames<'e>) -> GPoll<RecordValue<'e>>
where
N: Node<C> + ?Sized,
C: crate::context::ExtractArena<ArenaRef = &'e crate::arena::Arena>,

4
node-graph/libraries/core-types/src/record/testkit.rs
View File

@@ -3,7 +3,7 @@
use super::frames::{FrameArena, Frames};
use super::layout::{Layout, element_write};
use super::owned::OwnedRecord;
use super::serve::{FrameClaim, Served, serve_edge};
use super::serve::{FrameClaim, Served, serve_input};
use crate::gpoll::GPoll;
use crate::node::Node;
@@ -81,7 +81,7 @@ where
{
let scope = frames.scope();
let layout = node.layout().clone();
serve_edge(node, ctx, &scope).map(|value| ServedRecord {
serve_input(node, ctx, &scope).map(|value| ServedRecord {
// SAFETY: the poll served `value` at the node's declared layout and
// nothing has claimed frames since.
record: unsafe { OwnedRecord::copy_out(&layout, layout.rec(&value)) },

14
node-graph/libraries/core-types/src/registry.rs
View File

@@ -326,7 +326,7 @@ mod tests {
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, Ordering};
use crate::record::{FrameClaim, Layout, LiftedSource, Served, element_write, read_element, serve_edge};
use crate::record::{FrameClaim, Layout, LiftedSource, Served, element_write, read_element, serve_input};
fn counting() -> LiftedSource<u32, impl for<'c> Fn(&ContextImpl<'c>) -> GPoll<u32>> {
let count = AtomicU32::new(0);
@@ -383,7 +383,7 @@ mod tests {
assert_eq!(*handle.ty(), concrete!(String));
let wired = handle.downcast_erased::<ErasedRecordNode>(concrete!(String)).unwrap();
let GPoll::Final(value) = serve_edge(&wired, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&wired, &ctx, &frames) else {
panic!("borrow-carrying output must serve through the erased edge");
};
// SAFETY: the record was served at `layout`, whose element is the borrow.
@@ -466,7 +466,7 @@ mod tests {
let erased: Box<ErasedRecordNode> = Box::new(nested);
let frames = crate::record::test_frames(1 << 12);
let GPoll::Final(value) = serve_edge(&*erased, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&*erased, &ctx, &frames) else {
panic!("nested repeat must evaluate");
};
// SAFETY: the record was served at `layout`, whose element is the output.
@@ -545,7 +545,7 @@ mod tests {
let graph = ShiftFootprintNode::new(shifted, shifted_layout);
let layout = Node::<ContextImpl>::layout(&graph).clone();
let GPoll::Final(value) = serve_edge(&graph, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&graph, &ctx, &frames) else {
panic!("the footprint shift must reach the content");
};
// SAFETY: the record was served at `layout`, whose element is the resolution.
@@ -599,10 +599,10 @@ mod tests {
let second = duplicate.downcast_record::<u32>().unwrap();
// SAFETY: each record was served at `layout`, whose element is the count.
let count = |value| unsafe { layout.rec(&value).element::<u32>() };
assert_eq!(serve_edge(&first, &ctx, &frames).map(count), GPoll::Final(1));
assert_eq!(serve_edge(&second, &ctx, &frames).map(count), GPoll::Final(2));
assert_eq!(serve_input(&first, &ctx, &frames).map(count), GPoll::Final(1));
assert_eq!(serve_input(&second, &ctx, &frames).map(count), GPoll::Final(2));
drop(first);
assert_eq!(serve_edge(&second, &ctx, &frames).map(count), GPoll::Final(3));
assert_eq!(serve_input(&second, &ctx, &frames).map(count), GPoll::Final(3));
}
}

2
node-graph/node-macro/src/codegen.rs
View File

@@ -1606,7 +1606,7 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn
// The element copies out by value, so the edge's
// claim dies with the query.
let __scope = __frames.scope();
#core_types::record::serve_edge(&self.#name, __input, &__scope)
#core_types::record::serve_input(&self.#name, __input, &__scope)
.map(|__value| unsafe { #core_types::record::read_element::<#ty>(#layout.rec(&__value)) })
};
let #arg = #core_types::extent::ValueIn::new(&#query);

14
node-graph/nodes/gcore/src/memo.rs
View File

@@ -307,7 +307,7 @@ mod tests {
assert!(handle.serialize().is_none(), "no snapshot before the first eval");
let edge = handle.duplicate().downcast_record::<u32>().unwrap();
let GPoll::Final(_) = core_types::record::serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(_) = core_types::record::serve_input(&edge, &ctx, &frames) else {
panic!("expected a final record");
};
@@ -334,7 +334,7 @@ mod tests {
let handle = EdgeHandle::new_record::<u32>(Arc::new(monitor) as Arc<ErasedRecordNode>);
let edge = handle.duplicate().downcast_record::<u32>().unwrap();
let GPoll::Final(_) = core_types::record::serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(_) = core_types::record::serve_input(&edge, &ctx, &frames) else {
panic!("expected a final record");
};
@@ -496,7 +496,7 @@ mod tests {
let served_at = |arena: &Arena| {
let scope = scope_fixture(&generations, arena).with_persistent(&persistent);
let ctx = ContextImpl::root(&scope);
let GPoll::Final(value) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("the memo must serve a final record");
};
let element: &String = unsafe { core_types::record::borrow_element(layout.rec(&value)) };
@@ -627,7 +627,7 @@ mod tests {
let at = |lane: u64| {
let mut ctx = ContextImpl::root(&scope);
core_types::context::InjectIndex::set_index(&mut ctx, lane);
core_types::record::serve_edge(&memo, &ctx, &frames)
core_types::record::serve_input(&memo, &ctx, &frames)
};
let GPoll::Final(value) = at(1) else {
@@ -655,10 +655,10 @@ mod tests {
let layout = element_layout::<String>();
let memo = FrameMemoNode::new(lifted::<String>("lent out".to_string()), &layout);
let GPoll::Final(first) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Final(first) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("the miss must publish the record");
};
let GPoll::Final(second) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Final(second) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("the hit must revive the published record");
};
let first: &String = unsafe { core_types::record::borrow_element(layout.rec(&first)) };
@@ -679,7 +679,7 @@ mod tests {
let served_at = |arena: &Arena| {
let scope = scope_fixture(&generations, arena).with_persistent(&persistent);
let ctx = ContextImpl::root(&scope);
let GPoll::Final(value) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("the span memo must serve a final record");
};
let element: &String = unsafe { core_types::record::borrow_element(layout.rec(&value)) };

18
node-graph/nodes/gcore/src/record.rs
View File

@@ -1742,7 +1742,7 @@ mod tests {
let head = ctx.index_head();
for (lane, element) in [(0u64, 10.), (1, 11.)] {
let lane_frames = frames.scope();
let GPoll::Final(value) = core_types::record::serve_edge(&node, &ctx.promoted(&head, lane), &lane_frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&node, &ctx.promoted(&head, lane), &lane_frames) else {
panic!("expected a final record at lane {lane}");
};
let rec = out.rec(&value);
@@ -2180,7 +2180,7 @@ mod tests {
checked_multiply_opacity_layout_meta(),
&[Some(&source_layout)],
);
let GPoll::Error(error) = core_types::record::serve_edge(&failing, &ctx, &frames) else {
let GPoll::Error(error) = core_types::record::serve_input(&failing, &ctx, &frames) else {
panic!("expected an error");
};
assert!(error.kind == "negative factor");
@@ -2481,7 +2481,7 @@ mod tests {
for pass in ["the spawning eval", "the slot hit"] {
let scoped = frames.scope();
let GPoll::Final(value) = core_types::record::serve_edge(&node, &ctx, &scoped) else {
let GPoll::Final(value) = core_types::record::serve_input(&node, &ctx, &scoped) else {
panic!("an inline completion is final on {pass}");
};
let rec = layout.rec(&value);
@@ -2521,7 +2521,7 @@ mod tests {
),
&f64_layout(&[]),
);
let GPoll::Final(value) = core_types::record::serve_edge(&node, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&node, &ctx, &frames) else {
panic!("expected a final record");
};
let element = unsafe { Node::<ContextImpl>::layout(&node).rec(&value).element::<f64>() };
@@ -2621,7 +2621,7 @@ mod tests {
label_layout_meta(),
&[Some(&labeled)],
);
let GPoll::Final(value) = core_types::record::serve_edge(&chain, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&chain, &ctx, &frames) else {
panic!("expected a final record");
};
let rec = relabeled.rec(&value);
@@ -2867,7 +2867,7 @@ mod tests {
let chain = ForwardRecordNode::new(RecordSource::new(f64_record_source(&layout, 4., vec![("opacity", 0.25)]), &layout, &layout.clone()), &layout);
let GPoll::Final(value) = core_types::record::serve_edge(&chain, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&chain, &ctx, &frames) else {
panic!("expected a final record");
};
let rec = layout.rec(&value);
@@ -2955,7 +2955,7 @@ mod tests {
};
let memo = crate::memo::MemoizeNode::new(source, &layout);
let GPoll::Partial(_) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Partial(_) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("expected a partial record");
};
let GPoll::Partial(served) = core_types::record::capture(&memo, &ctx, &frames) else {
@@ -2985,7 +2985,7 @@ mod tests {
let scope = scope_fixture(&generations, &first_arena).with_persistent(&persistent);
let ctx = ContextImpl::root(&scope);
let mut first = frames.reborrow();
let GPoll::Final(_) = core_types::record::serve_edge(&memo, &ctx, &mut first) else {
let GPoll::Final(_) = core_types::record::serve_input(&memo, &ctx, &mut first) else {
panic!("expected a final record");
};
}
@@ -2995,7 +2995,7 @@ mod tests {
let later_arena = Arena::new(1024).unwrap();
let scope = scope_fixture(&generations, &later_arena).with_persistent(&persistent);
let ctx = ContextImpl::root(&scope);
let GPoll::Final(value) = core_types::record::serve_edge(&memo, &ctx, &frames) else {
let GPoll::Final(value) = core_types::record::serve_input(&memo, &ctx, &frames) else {
panic!("expected a final record");
};
let rec = labeled.rec(&value);

8
node-graph/nodes/graphic/src/record.rs
View File

@@ -708,7 +708,7 @@ mod tests {
assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::Exactly(1)), "the group is the level's single lane");
let head = ctx.index_head();
let GPoll::Final(value) = record::serve_edge(&node, &ctx.promoted(&head, 0), &frames) else {
let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
panic!("expected a final record");
};
let Graphic::Group(group) = (unsafe { record::borrow_element::<Graphic>(out.rec(&value)) }) else {
@@ -744,7 +744,7 @@ mod tests {
let out = Node::<ContextImpl>::layout(&node).clone();
let head = ctx.index_head();
let GPoll::Final(value) = record::serve_edge(&node, &ctx.promoted(&head, 0), &frames) else {
let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
panic!("expected a final record");
};
let copy = unsafe { (out.element.clone_out)(out.rec(&value).ptr()) };
@@ -846,7 +846,7 @@ mod tests {
);
let out = Node::<ContextImpl>::layout(&node).clone();
let head = ctx.index_head();
let GPoll::Final(value) = record::serve_edge(&node, &ctx.promoted(&head, 0), &frames) else {
let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
panic!("expected a final record");
};
let Graphic::Group(group) = (unsafe { record::borrow_element::<Graphic>(out.rec(&value)) }) else {
@@ -882,7 +882,7 @@ mod tests {
// SAFETY: the element is cloned out inside the scope, so no borrow
// into the frame escapes it.
let scope = frames.scope();
let GPoll::Final(value) = record::serve_edge(&wrapped, &ctx.promoted(&head, 0), &scope) else {
let GPoll::Final(value) = record::serve_input(&wrapped, &ctx.promoted(&head, 0), &scope) else {
panic!("expected a final record");
};
let group = unsafe { record::borrow_element::<Graphic>(wrap_out.rec(&value)) }.clone();

2
node-graph/nodes/gstd/src/render_node.rs
View File

@@ -274,7 +274,7 @@ mod tests {
lane_invariant: u32::MAX,
},
);
let GPoll::Final(result) = core_types::record::serve_edge(&graph, &ctx, &frames) else {
let GPoll::Final(result) = core_types::record::serve_input(&graph, &ctx, &frames) else {
panic!("create_context must complete synchronously");
};
let output: &RenderOutput = unsafe { core_types::record::borrow_element(layout.rec(&result)) };

18
node-graph/nodes/math/src/lib.rs
View File

@@ -1014,7 +1014,7 @@ mod graphene_test {
use core_types::context::{ContextImpl, EvalScope};
use core_types::gpoll::{Finality, GPoll};
use core_types::node::{BatchStatus, Node};
use core_types::record::{Layout, LiftedSource, RecordValue, serve_edge};
use core_types::record::{Layout, LiftedSource, RecordValue, serve_input};
use core_types::registry::{ErasedRecordNode, construct};
use core_types::value::record_value_edge;
use std::mem::MaybeUninit;
@@ -1073,7 +1073,7 @@ mod graphene_test {
let graph = installed(AddNode::<_, _, f64, f64>::new(a, b, &la, &lb), &out);
let frames = frames_for(&[&la, &lb, &out]);
let GPoll::Final(value) = serve_edge(&graph, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&graph, &ctx, &frames) else {
panic!("expected a final record");
};
assert_eq!(element::<f64>(&out, &value), 3.0);
@@ -1122,7 +1122,7 @@ mod graphene_test {
let edge = wired.downcast_record::<bool>().unwrap();
let frames = frames_for(&[&layout]);
let GPoll::Final(value) = serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&edge, &ctx, &frames) else {
panic!("expected a final record");
};
assert!(element::<bool>(&layout, &value));
@@ -1168,7 +1168,7 @@ mod graphene_test {
let edge = wired.downcast_record::<f64>().unwrap();
let frames = frames_for(&[&layout]);
let GPoll::Final(value) = serve_edge(&edge, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&edge, &ctx, &frames) else {
panic!("expected a final record");
};
assert_eq!(element::<f64>(&layout, &value), 4.0);
@@ -1215,7 +1215,7 @@ mod graphene_test {
let out = Node::<ContextImpl>::layout(&graph).clone();
let frames = frames_for(&[&lc, &lt, &lf, &out]);
let GPoll::Final(value) = serve_edge(&graph, &ctx, &frames) else {
let GPoll::Final(value) = serve_input(&graph, &ctx, &frames) else {
panic!("expected a final record");
};
assert_eq!(element::<f64>(&out, &value), 1.0);
@@ -1241,8 +1241,8 @@ mod graphene_test {
let out = Node::<ContextImpl>::layout(&partial).clone();
let frames = frames_for(&[&lc1, &lp1, &lpa1, &lc2, &lp2, &lpa2, &out]);
assert!(matches!(serve_edge(&pending, &ctx, &frames), GPoll::Pending));
let GPoll::Partial(value) = serve_edge(&partial, &ctx, &frames) else {
assert!(matches!(serve_input(&pending, &ctx, &frames), GPoll::Pending));
let GPoll::Partial(value) = serve_input(&partial, &ctx, &frames) else {
panic!("expected a partial record");
};
assert_eq!(element::<f64>(&out, &value), 7.0);
@@ -1262,7 +1262,7 @@ mod graphene_test {
let out = Node::<ContextImpl>::layout(&graph).clone();
let frames = frames_for(&[&lc, &lt, &lf, &out]);
let GPoll::Partial(value) = serve_edge(&graph, &ctx, &frames) else {
let GPoll::Partial(value) = serve_input(&graph, &ctx, &frames) else {
panic!("expected a partial record");
};
assert_eq!(element::<f64>(&out, &value), 1.0);
@@ -1280,7 +1280,7 @@ mod graphene_test {
let graph = installed(AddNode::<_, _, f64, f64>::new(fallback, src, &lfb, &ls), &out);
let frames = frames_for(&[&lfb, &ls, &out]);
let GPoll::Fallback(boxed) = serve_edge(&graph, &ctx, &frames) else {
let GPoll::Fallback(boxed) = serve_input(&graph, &ctx, &frames) else {
panic!("fallback must propagate with the computed stand-in");
};
assert_eq!(element::<f64>(&out, &boxed.0), 5.0);