From ad4847b5ac63483043aaea840e1dbf4a85f121a0 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 15:04:33 -0700 Subject: [PATCH 1/8] chore(quest): claim quest/m1/poll-first/machine.md Quest-Claim: 6d01e9891cd01934 From 8b454858f62e42b9f22d3d505b23b0bbed981fd6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:07:20 -0700 Subject: [PATCH 2/8] feat(kio): add #[kio::machine] and convert moq-net's straight-line machines (WIP) Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 33 + Cargo.toml | 4 +- rs/kio/Cargo.toml | 3 + rs/kio/macros/Cargo.toml | 33 + rs/kio/macros/src/lib.rs | 811 ++++++++++++++++ rs/kio/macros/tests/machine.rs | 194 ++++ rs/kio/macros/tests/ui.rs | 6 + rs/kio/macros/tests/ui/branch_wait.rs | 23 + rs/kio/macros/tests/ui/branch_wait.stderr | 5 + rs/kio/macros/tests/ui/break_outside_loop.rs | 26 + .../macros/tests/ui/break_outside_loop.stderr | 5 + rs/kio/macros/tests/ui/duplicate_wait.rs | 23 + rs/kio/macros/tests/ui/duplicate_wait.stderr | 11 + rs/kio/macros/tests/ui/every_poll_late.rs | 25 + rs/kio/macros/tests/ui/every_poll_late.stderr | 5 + rs/kio/macros/tests/ui/generic.rs | 18 + rs/kio/macros/tests/ui/generic.stderr | 5 + rs/kio/macros/tests/ui/hidden_borrow.rs | 23 + rs/kio/macros/tests/ui/hidden_borrow.stderr | 22 + rs/kio/macros/tests/ui/hidden_yield.rs | 24 + rs/kio/macros/tests/ui/hidden_yield.stderr | 5 + rs/kio/macros/tests/ui/missing_try.rs | 23 + rs/kio/macros/tests/ui/missing_try.stderr | 18 + rs/kio/macros/tests/ui/not_send.rs | 27 + rs/kio/macros/tests/ui/not_send.stderr | 29 + rs/kio/macros/tests/ui/poll_moves.rs | 26 + rs/kio/macros/tests/ui/poll_moves.stderr | 19 + rs/kio/macros/tests/ui/poll_type.rs | 23 + rs/kio/macros/tests/ui/poll_type.stderr | 15 + rs/kio/macros/tests/ui/segment_type.rs | 23 + rs/kio/macros/tests/ui/segment_type.stderr | 12 + rs/kio/macros/tests/ui/self_borrow.rs | 23 + rs/kio/macros/tests/ui/self_borrow.stderr | 5 + rs/kio/macros/tests/ui/untyped.rs | 23 + rs/kio/macros/tests/ui/untyped.stderr | 5 + rs/kio/macros/tests/ui/wrong_annotation.rs | 23 + .../macros/tests/ui/wrong_annotation.stderr | 17 + rs/kio/src/lib.rs | 3 + rs/moq-net/Cargo.toml | 2 +- rs/moq-net/src/lite/publisher.rs | 133 ++- rs/moq-net/src/lite/session.rs | 177 ++-- rs/moq-net/src/lite/subscriber.rs | 891 +++++++----------- 42 files changed, 2098 insertions(+), 723 deletions(-) create mode 100644 rs/kio/macros/Cargo.toml create mode 100644 rs/kio/macros/src/lib.rs create mode 100644 rs/kio/macros/tests/machine.rs create mode 100644 rs/kio/macros/tests/ui.rs create mode 100644 rs/kio/macros/tests/ui/branch_wait.rs create mode 100644 rs/kio/macros/tests/ui/branch_wait.stderr create mode 100644 rs/kio/macros/tests/ui/break_outside_loop.rs create mode 100644 rs/kio/macros/tests/ui/break_outside_loop.stderr create mode 100644 rs/kio/macros/tests/ui/duplicate_wait.rs create mode 100644 rs/kio/macros/tests/ui/duplicate_wait.stderr create mode 100644 rs/kio/macros/tests/ui/every_poll_late.rs create mode 100644 rs/kio/macros/tests/ui/every_poll_late.stderr create mode 100644 rs/kio/macros/tests/ui/generic.rs create mode 100644 rs/kio/macros/tests/ui/generic.stderr create mode 100644 rs/kio/macros/tests/ui/hidden_borrow.rs create mode 100644 rs/kio/macros/tests/ui/hidden_borrow.stderr create mode 100644 rs/kio/macros/tests/ui/hidden_yield.rs create mode 100644 rs/kio/macros/tests/ui/hidden_yield.stderr create mode 100644 rs/kio/macros/tests/ui/missing_try.rs create mode 100644 rs/kio/macros/tests/ui/missing_try.stderr create mode 100644 rs/kio/macros/tests/ui/not_send.rs create mode 100644 rs/kio/macros/tests/ui/not_send.stderr create mode 100644 rs/kio/macros/tests/ui/poll_moves.rs create mode 100644 rs/kio/macros/tests/ui/poll_moves.stderr create mode 100644 rs/kio/macros/tests/ui/poll_type.rs create mode 100644 rs/kio/macros/tests/ui/poll_type.stderr create mode 100644 rs/kio/macros/tests/ui/segment_type.rs create mode 100644 rs/kio/macros/tests/ui/segment_type.stderr create mode 100644 rs/kio/macros/tests/ui/self_borrow.rs create mode 100644 rs/kio/macros/tests/ui/self_borrow.stderr create mode 100644 rs/kio/macros/tests/ui/untyped.rs create mode 100644 rs/kio/macros/tests/ui/untyped.stderr create mode 100644 rs/kio/macros/tests/ui/wrong_annotation.rs create mode 100644 rs/kio/macros/tests/ui/wrong_annotation.stderr diff --git a/Cargo.lock b/Cargo.lock index ba196af3414..fc92b994101 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4601,11 +4601,23 @@ dependencies = [ "criterion", "crossbeam-epoch", "futures", + "kio-macros", "loom", "smallvec", "tokio", ] +[[package]] +name = "kio-macros" +version = "0.1.0" +dependencies = [ + "kio 0.6.2", + "proc-macro2", + "quote", + "syn 2.0.119", + "trybuild", +] + [[package]] name = "kqueue" version = "1.2.1" @@ -10396,6 +10408,12 @@ version = "0.13.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca" +[[package]] +name = "target-tuple" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "876fef147edbcbddc8ac5cbbba92c7b86519e314e86638596c09673b2ed01e7f" + [[package]] name = "tempfile" version = "3.27.0" @@ -11049,6 +11067,21 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +[[package]] +name = "trybuild" +version = "1.0.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62db9c92d704393fbf2132041720cc80b689f2d3f28521015c2ac866223c11b8" +dependencies = [ + "glob", + "serde", + "serde_derive", + "serde_json", + "target-tuple", + "termcolor", + "toml 1.1.6+spec-1.1.0", +] + [[package]] name = "ttf-parser" version = "0.25.1" diff --git a/Cargo.toml b/Cargo.toml index c96c253118d..c42701b4313 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,9 +1,10 @@ [workspace] # Keep source-only members discoverable in Maturin's dependency-pruned archive, # including the separately packaged UniFFI generator. -members = ["demo/carla/bridge", "rs/*", "rs/moq-clock/macros", "rs/moq-net/fuzz", "rs/moq-quic/fuzz"] +members = ["demo/carla/bridge", "rs/*", "rs/kio/macros", "rs/moq-clock/macros", "rs/moq-net/fuzz", "rs/moq-quic/fuzz"] default-members = [ "rs/kio", + "rs/kio/macros", "rs/hang", # "rs/moq-c", # requires C toolchain "rs/moq-clock", @@ -127,6 +128,7 @@ indexmap = "2.14.2" io-uring = "0.7.15" jsonwebtoken = "11" kio = { version = "0.6.2", path = "rs/kio" } +kio-macros = { version = "0.1.0", path = "rs/kio/macros" } libc = "0.2" libloading = "0.9" linux-raw-sys = { version = "0.12.1", features = ["ioctl"] } diff --git a/rs/kio/Cargo.toml b/rs/kio/Cargo.toml index deb8af47795..f73ed49d403 100644 --- a/rs/kio/Cargo.toml +++ b/rs/kio/Cargo.toml @@ -13,12 +13,15 @@ keywords = ["async", "producer", "consumer", "state", "sync"] categories = ["asynchronous", "concurrency"] [features] +# `#[kio::machine]`, which writes a `poll_*` state machine from straight-line code. +macros = ["dep:kio-macros"] # Per-task Ready poll accounting for deterministic simulators, never production. _sim = [] [dependencies] # Frees a log's evicted segments once no read that could reach them is running. crossbeam-epoch = "0.9.21" +kio-macros = { workspace = true, optional = true } smallvec = { version = "1.15", features = ["union"] } # Loom swaps in its own Arc/Mutex/atomics so it can permute every interleaving. diff --git a/rs/kio/macros/Cargo.toml b/rs/kio/macros/Cargo.toml new file mode 100644 index 00000000000..4d3ae94692f --- /dev/null +++ b/rs/kio/macros/Cargo.toml @@ -0,0 +1,33 @@ +# The `#[kio::machine]` attribute. A separate crate only because a proc macro +# must be; `kio` re-exports it behind its `macros` feature. +[package] +name = "kio-macros" +description = "The #[kio::machine] attribute; use it through kio's macros feature." +authors = ["Luke Curley"] +repository = "https://github.com/moq-dev/moq" +license = "MIT OR Apache-2.0" + +version = "0.1.0" +edition = "2024" +rust-version.workspace = true + +keywords = ["async", "poll", "state-machine"] +categories = ["asynchronous"] + +[lib] +proc-macro = true + +[dependencies] +proc-macro2 = "1" +quote = "1" +# syn 2, not 3: moq-net's graph already builds syn 2 with `full` and `visit-mut` +# (thiserror, tracing), so the macro adds no syn build of its own there. +syn = { version = "2", features = ["full", "visit-mut"] } + +[dev-dependencies] +kio = { path = "..", features = ["macros"] } +# Compiles each mistake in `tests/ui/` and checks the diagnostic it reports. +trybuild = "1" + +[lints] +workspace = true diff --git a/rs/kio/macros/src/lib.rs b/rs/kio/macros/src/lib.rs new file mode 100644 index 00000000000..8e83fc36981 --- /dev/null +++ b/rs/kio/macros/src/lib.rs @@ -0,0 +1,811 @@ +//! The `#[kio::machine]` attribute: a `poll_*` state machine from straight-line code. +//! +//! Use it through `kio`'s `macros` feature, which re-exports it and documents the +//! dialect. + +use std::collections::HashSet; + +use proc_macro2::{Spacing, Span, TokenStream, TokenTree}; +use quote::{ToTokens, format_ident, quote, quote_spanned}; +use syn::{ + Expr, Ident, ImplItem, ItemImpl, Macro, Pat, Stmt, Token, Type, + parse::{Parse, ParseStream}, + parse_macro_input, + spanned::Spanned, + visit_mut::{self, VisitMut}, +}; + +/// Write one `poll_*` method of an `impl` as straight-line code with explicit waits. +/// +/// `#[kio::machine(self.state: Name)]` on an `impl` generates `enum Name` and rewrites +/// the one method that uses `wait!` to resume from `self.state`. The struct declares +/// `state: Name` and starts it at `Name::Start`. Each wait gets a variant holding the +/// struct of the locals that live across it, `Name`, and the machine is +/// `Name::Done` once it returns `Poll::Ready`. `Name::name()` says where it waits. +/// +/// ``` +/// use std::task::Poll; +/// +/// struct Sum { +/// values: kio::Queue, +/// state: SumState, +/// } +/// +/// #[kio::machine(self.state: SumState)] +/// impl Sum { +/// fn poll_sum(&mut self, waiter: &kio::Waiter) -> Poll> { +/// // Lives across the second wait, so it needs a type. +/// let first: u64 = wait!(First => self.values.poll_pop(waiter))?; +/// let second = wait!(Second => self.values.poll_pop(waiter))?; +/// Poll::Ready(Ok(first + second)) +/// } +/// } +/// +/// let values = kio::Queue::new(); +/// let mut sum = Sum { values: values.clone(), state: SumState::Start }; +/// let waiter = kio::Waiter::noop(); +/// +/// values.try_push(1).unwrap(); +/// assert!(sum.poll_sum(&waiter).is_pending()); +/// assert_eq!(sum.state.name(), "Second"); +/// values.try_push(2).unwrap(); +/// assert_eq!(sum.poll_sum(&waiter), Poll::Ready(Ok(3))); +/// ``` +/// +/// - `wait!(Step => poll)` starts a top-level statement, as in `let x: T = wait!(Step => +/// poll)?;`. It evaluates `poll`, any `Poll<_>` expression, on every call until it is +/// ready, then continues with its value. Inside `poll`, earlier locals are `&mut` +/// borrows of the stored state, so moving one (`drop(x)`) is an error, and a `return` +/// or `ready!` leaves the machine at the wait. +/// - `#[every_poll]` statements lead the body and run on every call, before resuming. +/// - Every other statement runs once, so it must not return `Poll::Pending` or use +/// `ready!`. +/// - A local used after a wait must be bound as `let name: Type`, since its type +/// becomes a field. It is dropped when the machine leaves the last wait it lives +/// across, as a hand-written machine would. +/// - The body ends in its `Poll::Ready` value. Polling a `Done` machine panics. +/// - `Name` is `Send` when every stored local is. A `!Send` local reports its `let` +/// and its wait. +/// +/// Not supported: +/// +/// - A wait inside a branch or a loop. A conditional wait can be one that is ready at +/// once: `wait!(Step => if more { poll } else { Poll::Ready(None) })`. +/// - Generic impls. +/// - A borrow kept across a wait, such as of `self`: the state has no lifetime to +/// borrow with. A visible one (`&T`, `Foo<'a>`) is an error naming the local; one +/// hidden by an elided lifetime (`Ref`) is rustc's missing lifetime specifier +/// (E0106). Keep an owned handle instead, or borrow again inside the next wait. +#[proc_macro_attribute] +pub fn machine(args: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream { + let args = parse_macro_input!(args as Args); + let item = parse_macro_input!(item as ItemImpl); + expand(args, item).unwrap_or_else(syn::Error::into_compile_error).into() +} + +/// `self.: `. +struct Args { + field: Ident, + state: Ident, +} + +impl Parse for Args { + fn parse(input: ParseStream) -> syn::Result { + input.parse::()?; + input.parse::()?; + let field = input.parse()?; + input.parse::()?; + let state = input.parse()?; + Ok(Self { field, state }) + } +} + +fn expand(args: Args, mut item: ItemImpl) -> syn::Result { + if !item.generics.params.is_empty() { + return Err(syn::Error::new_spanned( + &item.generics, + "#[kio::machine] does not support generic impls", + )); + } + + let mut found = None; + for impl_item in &mut item.items { + let ImplItem::Fn(method) = impl_item else { continue }; + if Waits::first_in(&method.block).is_none() { + continue; + } + if found.is_some() { + return Err(syn::Error::new_spanned( + &method.sig, + "#[kio::machine] lowers one method per impl", + )); + } + let (body, variants) = lower(&args, &method.block.stmts)?; + method.block.stmts = vec![Stmt::Expr(syn::parse2(body)?, None)]; + found = Some((method.sig.ident.clone(), variants)); + } + let Some((method, variants)) = found else { + return Err(syn::Error::new( + Span::call_site(), + "no method in this impl uses `wait!`", + )); + }; + + let state = &args.state; + let doc = format!( + "Where `{}::{method}` is waiting.", + item.self_ty.to_token_stream().to_string().replace(' ', "") + ); + let defs = variants.iter().map(|variant| { + let name = &variant.name; + let storage = &variant.storage; + let doc = format!("Waiting at `wait!({name} => ..)`."); + quote! { + #[doc = #doc] + #name(#storage) + } + }); + let storages = variants.iter().map(storage); + let names = variants.iter().map(|variant| { + let name = &variant.name; + let label = name.to_string(); + quote! { #state::#name(_) => #label } + }); + + Ok(quote! { + #item + + #[doc = #doc] + #[allow(clippy::large_enum_variant, reason = "a machine's enum is its storage")] + enum #state { + /// Not polled yet. + Start, + #(#defs,)* + /// Returned `Poll::Ready`. + Done, + } + + #(#storages)* + + impl #state { + /// The wait it is parked at, for logs and drop handlers. + #[allow(dead_code, reason = "inspection only")] + fn name(&self) -> &'static str { + match self { + #state::Start => "Start", + #(#names,)* + #state::Done => "Done", + } + } + } + }) +} + +/// One variant's struct of the locals that live across its wait, with their `Send`. +fn storage(variant: &Variant) -> TokenStream { + let name = &variant.storage; + let doc = format!("The locals stored across `wait!({} => ..)`.", variant.name); + let fields = variant.stored.iter().map(|local| { + let ident = &local.ident; + let ty = &local.ty; + quote! { #ident: #ty } + }); + let def = quote! { + #[doc = #doc] + struct #name { #(#fields),* } + }; + if variant.stored.is_empty() { + return def; + } + + // The auto impl, written out so that a `!Send` local reports its own `let` (the + // bound) and its wait (the impl) instead of only the enum. The bound is + // higher-ranked so rustc checks it where `Send` is needed, not here. + let bounds = variant.stored.iter().map(|local| { + let ty = &local.ty; + let send = quote_spanned!(local.ident.span()=> ::core::marker::Send); + quote! { for<'__kio> #ty: #send } + }); + let header = quote_spanned!(variant.name.span()=> unsafe impl ::core::marker::Send for #name); + quote! { + #def + + // SAFETY: these are the auto impl's own conditions, every field's type being + // `Send`; the fields above are all there is. + #header where #(#bounds),* {} + } +} + +struct Variant { + /// The wait's name, the enum variant. + name: Ident, + /// The struct the variant holds, ``. + storage: Ident, + stored: Vec, +} + +struct Stored { + ident: Ident, + ty: Type, + mutable: bool, + /// The wait's poll reads it, by `&mut`. + polled: bool, + /// A later statement reads it, by value. + after: bool, +} + +/// `wait!(Step => poll)`. +struct Wait { + name: Ident, + poll: Expr, +} + +impl Parse for Wait { + fn parse(input: ParseStream) -> syn::Result { + let name = input.parse()?; + input.parse::]>()?; + let poll = input.parse()?; + Ok(Self { name, poll }) + } +} + +/// A top-level `let` binding, in scope until shadowed. +struct Local { + ident: Ident, + ty: Option, + mutable: bool, +} + +fn lower(args: &Args, stmts: &[Stmt]) -> syn::Result<(TokenStream, Vec)> { + let ready = Ident::new("ready", Span::mixed_site()); + + // `#[every_poll]` statements lead the body. + let mut every = Vec::new(); + let mut rest = stmts.iter().peekable(); + while let Some(stmt) = rest.peek() { + let Some(stmt) = strip_every_poll(stmt)? else { break }; + if let Some(span) = Waits::first(&stmt) { + return Err(syn::Error::new(span, "`wait!` cannot run every poll")); + } + every.push(stmt); + rest.next(); + } + + // Split the rest at each wait: `segments[k + 1]` starts with the statement + // that `waits[k]` resumes into. + let mut segments: Vec> = vec![Vec::new()]; + let mut waits: Vec = Vec::new(); + for stmt in rest { + if let Some(at) = strip_every_poll(stmt)? { + return Err(syn::Error::new_spanned(at, "`#[every_poll]` statements lead the body")); + } + let mut stmt = stmt.clone(); + let wait = head_wait(&mut stmt, &ready)?; + if let Some(span) = Waits::first(&stmt) { + return Err(syn::Error::new( + span, + "`wait!` must start a top-level statement, outside any branch or loop: `let x: T = wait!(Step => poll)?;`", + )); + } + if let Some(wait) = wait { + if let Some(span) = Waits::first_in_expr(&wait.poll) { + return Err(syn::Error::new(span, "a `wait!` cannot nest in another")); + } + if let Some(other) = waits.iter().find(|other| other.name == wait.name) { + let mut err = syn::Error::new(wait.name.span(), format!("a second `wait!({} => ..)`", wait.name)); + err.combine(syn::Error::new(other.name.span(), "the first is here")); + return Err(err); + } + if matches!(wait.name.to_string().as_str(), "Start" | "Done") { + return Err(syn::Error::new( + wait.name.span(), + format!("`{}` names a state the machine generates; pick another", wait.name), + )); + } + waits.push(wait); + segments.push(Vec::new()); + } + segments.last_mut().unwrap().push(stmt); + } + + for (k, segment) in segments.iter().enumerate() { + for stmt in segment { + check_segment(stmt)?; + } + if k < waits.len() { + check_loops(&waits[k].poll)?; + } + } + + // The last statement is the value. + let last = segments.last_mut().unwrap(); + match last.pop() { + Some(Stmt::Expr(value, None)) => last.push(syn::parse2(quote! { return #value; })?), + Some(stmt @ Stmt::Expr(Expr::Return(_), _)) => last.push(stmt), + other => { + let span = other.map_or_else(Span::call_site, |stmt| stmt.span()); + return Err(syn::Error::new( + span, + "a #[kio::machine] body ends in its `Poll::Ready` value", + )); + } + } + + // Tokenize each statement once: every token is a call into the compiler. + let reads: Vec> = segments + .iter() + .map(|segment| segment.iter().map(Reads::new).collect()) + .collect(); + let polls: Vec> = waits.iter().map(|wait| uses(wait.poll.to_token_stream())).collect(); + + // Each wait stores the in-scope locals its poll or a later statement reads. + // Each local remembers its declaring statement, by segment and index. + let mut scope: Vec<(Local, (usize, usize))> = Vec::new(); + // A stored `let mut` may be mutated only after a wait, out of rustc's sight. + let mut quiet = HashSet::new(); + let mut variants = Vec::new(); + for (k, wait) in waits.iter().enumerate() { + for (i, stmt) in segments[k].iter().enumerate() { + if let Stmt::Local(local) = stmt { + for binding in bindings(&local.pat) { + scope.retain(|(old, _)| old.ident != binding.ident); + scope.push((binding, (k, i))); + } + } + } + + let mut stored = Vec::new(); + for (local, decl) in &scope { + let name = local.ident.to_string(); + let polled = polls[k].contains(&name); + let after = used_later(&name, &reads[k + 1..], &polls[k + 1..]); + if !polled && !after { + continue; + } + let Some(ty) = local.ty.clone() else { + return Err(syn::Error::new_spanned( + &local.ident, + format!( + "`{}` lives across `wait!({} => ..)`, so it is stored in `{}::{}`: give it a type, `let {}: Type`", + local.ident, wait.name, args.state, wait.name, local.ident, + ), + )); + }; + if let Some(span) = borrows(&ty) { + return Err(syn::Error::new( + span, + format!( + "`{}` lives across `wait!({} => ..)`, so it is stored in `{}::{}`, which cannot hold a borrow: store an owned value, or borrow again inside the wait", + local.ident, wait.name, args.state, wait.name, + ), + )); + } + if local.mutable { + quiet.insert(*decl); + } + stored.push(Stored { + ident: local.ident.clone(), + ty, + mutable: local.mutable, + polled, + after, + }); + } + variants.push(Variant { + name: wait.name.clone(), + storage: format_ident!("{}{}", args.state, wait.name, span = wait.name.span()), + stored, + }); + } + + for (k, i) in quiet { + if let Stmt::Local(local) = &mut segments[k][i] { + local + .attrs + .push(syn::parse_quote!(#[allow(unused_mut, reason = "mutated after a wait")])); + } + } + + let Args { field, state } = args; + let store = |variant: &Variant| { + let name = &variant.name; + let storage = &variant.storage; + let idents = variant.stored.iter().map(|local| &local.ident); + quote! { self.#field = #state::#name(#storage { #(#idents),* }); } + }; + + let first = &segments[0]; + let first_store = store(&variants[0]); + let mut arms = vec![quote! { + #state::Start => { + self.#field = #state::Done; + #(#first)* + #first_store + } + }]; + + for (k, (wait, variant)) in waits.iter().zip(&variants).enumerate() { + let name = &variant.name; + let storage = &variant.storage; + let poll = &wait.poll; + let borrowed = variant + .stored + .iter() + .filter(|local| local.polled) + .map(|local| &local.ident); + let owned: Vec<_> = variant + .stored + .iter() + .filter(|local| local.after) + .map(|local| { + let ident = &local.ident; + match local.mutable { + true => quote! { #ident: mut #ident }, + false => quote! { #ident }, + } + }) + .collect(); + let take = if owned.is_empty() { + quote! { self.#field = #state::Done; } + } else { + quote! { + #[allow(unused_mut, reason = "mutated after a wait")] + let #state::#name(#storage { #(#owned,)* .. }) = ::core::mem::replace(&mut self.#field, #state::Done) else { + ::core::unreachable!() + }; + } + }; + let segment = &segments[k + 1]; + let next = variants.get(k + 1).map(store); + // The poll sees the stored locals as `&mut`, so moving one would only drop the + // reference: deny that rather than let it compile to nothing. + arms.push(quote! { + #state::#name(_) => { + let #ready = { + #[allow(unused_variables, reason = "bound for the poll")] + let #state::#name(#storage { #(#borrowed,)* .. }) = &mut self.#field else { + ::core::unreachable!() + }; + #[deny(dropping_references, forgetting_references)] + let #ready = match #poll { + ::core::task::Poll::Ready(#ready) => #ready, + ::core::task::Poll::Pending => return ::core::task::Poll::Pending, + }; + #ready + }; + #take + #(#segment)* + #next + } + }); + } + + let body = quote! {{ + #(#every)* + loop { + match self.#field { + #(#arms)* + #state::Done => ::core::panic!("polled after returning `Poll::Ready`"), + } + } + }}; + Ok((body, variants)) +} + +/// The statement without its leading `#[every_poll]`, if it has one. +fn strip_every_poll(stmt: &Stmt) -> syn::Result> { + let mut tokens = stmt.to_token_stream().into_iter(); + let (Some(TokenTree::Punct(pound)), Some(TokenTree::Group(attr))) = (tokens.next(), tokens.next()) else { + return Ok(None); + }; + if pound.as_char() != '#' || attr.stream().to_string() != "every_poll" { + return Ok(None); + } + let rest: TokenStream = tokens.collect(); + Ok(Some(syn::parse2(rest)?)) +} + +/// Takes the `wait!` this statement evaluates first, leaving `ready` in its place. +fn head_wait(stmt: &mut Stmt, ready: &Ident) -> syn::Result> { + fn head(expr: &mut Expr, ready: &Ident) -> syn::Result> { + match expr { + Expr::Macro(mac) if is_wait(&mac.mac) => { + let wait = mac.mac.parse_body()?; + // Point type errors on the value at the `wait!`, not the attribute. + let ready = Ident::new("ready", ready.span().located_at(mac.mac.span())); + *expr = syn::parse_quote!(#ready); + Ok(Some(wait)) + } + Expr::Try(inner) => head(&mut inner.expr, ready), + Expr::MethodCall(inner) => head(&mut inner.receiver, ready), + Expr::Field(inner) => head(&mut inner.base, ready), + Expr::Binary(inner) => head(&mut inner.left, ready), + Expr::Cast(inner) => head(&mut inner.expr, ready), + Expr::Paren(inner) => head(&mut inner.expr, ready), + Expr::Unary(inner) => head(&mut inner.expr, ready), + Expr::Reference(inner) => head(&mut inner.expr, ready), + Expr::Index(inner) => head(&mut inner.expr, ready), + // Only the scrutinee: a wait in an arm is a branch. + Expr::Match(inner) => head(&mut inner.expr, ready), + // A path call evaluates nothing before its first argument. + Expr::Call(inner) if matches!(*inner.func, Expr::Path(_)) => match inner.args.first_mut() { + Some(first) => head(first, ready), + None => Ok(None), + }, + _ => Ok(None), + } + } + + match stmt { + Stmt::Local(local) => match &mut local.init { + Some(init) => head(&mut init.expr, ready), + None => Ok(None), + }, + Stmt::Expr(inner, _) => head(inner, ready), + // A bare `wait!(..);` must be ready with `()`; without the `;`, it is the value. + Stmt::Macro(mac) if is_wait(&mac.mac) => { + let wait = mac.mac.parse_body()?; + let ready = Ident::new("ready", ready.span().located_at(mac.mac.span())); + *stmt = match mac.semi_token { + Some(_) => syn::parse_quote!(let () = #ready;), + None => Stmt::Expr(syn::parse_quote!(#ready), None), + }; + Ok(Some(wait)) + } + _ => Ok(None), + } +} + +fn is_wait(mac: &Macro) -> bool { + mac.path.is_ident("wait") +} + +/// Finds the first `wait!` anywhere, including inside closures. +#[derive(Default)] +struct Waits(Option); + +impl Waits { + fn first_in(block: &syn::Block) -> Option { + let mut waits = Self::default(); + waits.visit_block_mut(&mut block.clone()); + waits.0 + } + + fn first_in_expr(expr: &Expr) -> Option { + let mut waits = Self::default(); + waits.visit_expr_mut(&mut expr.clone()); + waits.0 + } + + fn first(stmt: &Stmt) -> Option { + let mut waits = Self::default(); + waits.visit_stmt_mut(&mut stmt.clone()); + waits.0 + } +} + +impl VisitMut for Waits { + fn visit_macro_mut(&mut self, mac: &mut Macro) { + if is_wait(mac) && self.0.is_none() { + self.0 = Some(mac.span()); + } + } +} + +/// A run-once statement yields only through `wait!`. +fn check_segment(stmt: &Stmt) -> syn::Result<()> { + fn hidden(tokens: TokenStream) -> Option { + let mut tokens = tokens.into_iter().peekable(); + while let Some(token) = tokens.next() { + match token { + TokenTree::Ident(ident) if ident == "Pending" => return Some(ident.span()), + TokenTree::Ident(ident) + if (ident == "ready" || ident == "pending") + && matches!(tokens.peek(), Some(TokenTree::Punct(bang)) if bang.as_char() == '!') => + { + return Some(ident.span()); + } + TokenTree::Group(group) => { + if let Some(span) = hidden(group.stream()) { + return Some(span); + } + } + _ => {} + } + } + None + } + + if let Some(span) = hidden(stmt.to_token_stream()) { + return Err(syn::Error::new( + span, + "this statement runs once, so it cannot return `Poll::Pending`: wait with `let x: T = wait!(Step => poll)?;`", + )); + } + let mut stmt = stmt.clone(); + let mut loops = Loops::default(); + loops.visit_stmt_mut(&mut stmt); + loops.0.map_or(Ok(()), Err) +} + +fn check_loops(poll: &Expr) -> syn::Result<()> { + let mut loops = Loops::default(); + loops.visit_expr_mut(&mut poll.clone()); + loops.0.map_or(Ok(()), Err) +} + +/// An unlabeled `break` or `continue` outside the user's own loops would exit the +/// machine's resume loop instead. +#[derive(Default)] +struct Loops(Option, usize); + +impl VisitMut for Loops { + fn visit_expr_mut(&mut self, expr: &mut Expr) { + match expr { + Expr::Loop(_) | Expr::While(_) | Expr::ForLoop(_) => { + self.1 += 1; + visit_mut::visit_expr_mut(self, expr); + self.1 -= 1; + } + Expr::Closure(_) | Expr::Async(_) => {} + Expr::Break(syn::ExprBreak { label: None, .. }) | Expr::Continue(syn::ExprContinue { label: None, .. }) + if self.1 == 0 && self.0.is_none() => + { + self.0 = Some(syn::Error::new_spanned( + expr, + "`break` and `continue` need a loop of their own", + )); + } + _ => visit_mut::visit_expr_mut(self, expr), + } + } + + fn visit_item_mut(&mut self, _: &mut syn::Item) {} +} + +/// The names a top-level `let` binds. Only `let name: Type` carries a type, and +/// `let (a, b): (A, B)` one for each name. +fn bindings(pat: &Pat) -> Vec { + if let Pat::Type(typed) = pat + && let Some(typed) = typed_bindings(&typed.pat, &typed.ty) + { + return typed; + } + + #[derive(Default)] + struct Idents(Vec); + impl VisitMut for Idents { + fn visit_pat_ident_mut(&mut self, ident: &mut syn::PatIdent) { + self.0.push(Local { + ident: ident.ident.clone(), + ty: None, + mutable: ident.mutability.is_some(), + }); + visit_mut::visit_pat_ident_mut(self, ident); + } + } + let mut idents = Idents::default(); + idents.visit_pat_mut(&mut pat.clone()); + idents.0 +} + +/// The names `pat` binds, each typed by its part of `ty`, if the two line up. +fn typed_bindings(pat: &Pat, ty: &Type) -> Option> { + match (pat, ty) { + (Pat::Ident(ident), _) if ident.by_ref.is_none() && ident.subpat.is_none() => Some(vec![Local { + ident: ident.ident.clone(), + ty: Some(ty.clone()), + mutable: ident.mutability.is_some(), + }]), + (Pat::Wild(_), _) => Some(Vec::new()), + (Pat::Tuple(pats), Type::Tuple(tys)) if pats.elems.len() == tys.elems.len() => { + let mut locals = Vec::new(); + for (pat, ty) in pats.elems.iter().zip(&tys.elems) { + locals.extend(typed_bindings(pat, ty)?); + } + Some(locals) + } + (_, Type::Paren(inner)) => typed_bindings(pat, &inner.elem), + _ => None, + } +} + +/// Where a type borrows, through a `&` or a lifetime other than `'static`, outside a +/// function signature's own. A borrow hidden by an elided path lifetime (`Ref`) goes +/// unseen, and rustc reports it as a missing lifetime specifier instead. +fn borrows(ty: &Type) -> Option { + #[derive(Default)] + struct Borrows(Option); + impl VisitMut for Borrows { + fn visit_type_reference_mut(&mut self, reference: &mut syn::TypeReference) { + self.0.get_or_insert(reference.and_token.span); + } + fn visit_lifetime_mut(&mut self, lifetime: &mut syn::Lifetime) { + if lifetime.ident != "static" { + self.0.get_or_insert(lifetime.span()); + } + } + fn visit_type_bare_fn_mut(&mut self, _: &mut syn::TypeBareFn) {} + fn visit_parenthesized_generic_arguments_mut(&mut self, _: &mut syn::ParenthesizedGenericArguments) {} + } + let mut borrows = Borrows::default(); + borrows.visit_type_mut(&mut ty.clone()); + borrows.0 +} + +/// Every identifier that could name a local: not a field, method, or path tail, nor a +/// macro's named argument (`tracing::debug!(prefix = %root)`). +fn uses(tokens: TokenStream) -> HashSet { + fn walk(tokens: TokenStream, in_macro: bool, into: &mut HashSet) { + let punct = |token: &Option, c: char| matches!(token, Some(TokenTree::Punct(p)) if p.as_char() == c); + let (mut prev, mut prev2) = (None, None); + let mut tokens = tokens.into_iter().peekable(); + while let Some(token) = tokens.next() { + let tail = punct(&prev, '.') || (punct(&prev, ':') && punct(&prev2, ':')); + match &token { + TokenTree::Ident(ident) if !tail => { + let named = in_macro + && matches!(tokens.peek(), Some(TokenTree::Punct(eq)) if eq.as_char() == '=' && eq.spacing() == Spacing::Alone); + if !named { + into.insert(ident.to_string()); + } + } + TokenTree::Group(group) => walk(group.stream(), in_macro || punct(&prev, '!'), into), + _ => {} + } + prev2 = prev.replace(token); + } + } + let mut into = HashSet::new(); + walk(tokens, false, &mut into); + into +} + +/// What a statement reads, and what it binds if it is a `let`. +struct Reads { + uses: HashSet, + binds: Vec, +} + +impl Reads { + fn new(stmt: &Stmt) -> Self { + let Stmt::Local(local) = stmt else { + return Self { + uses: uses(stmt.to_token_stream()), + binds: Vec::new(), + }; + }; + // The initializer only: the pattern names what it binds, not what it reads. + let uses = local.init.as_ref().map_or_else(HashSet::new, |init| { + let mut tokens = init.expr.to_token_stream(); + if let Some((_, diverge)) = &init.diverge { + tokens.extend(diverge.to_token_stream()); + } + self::uses(tokens) + }); + let binds = bindings(&local.pat) + .iter() + .map(|local| local.ident.to_string()) + .collect(); + Self { uses, binds } + } +} + +/// Whether `name` is read after a wait, before a later `let` shadows it. +/// `polls[k]` is the wait that ends `segments[k]`. +fn used_later(name: &str, segments: &[Vec], polls: &[HashSet]) -> bool { + for (k, segment) in segments.iter().enumerate() { + for reads in segment { + if reads.uses.contains(name) { + return true; + } + if reads.binds.iter().any(|bind| bind == name) { + return false; + } + } + if polls.get(k).is_some_and(|poll| poll.contains(name)) { + return true; + } + } + false +} diff --git a/rs/kio/macros/tests/machine.rs b/rs/kio/macros/tests/machine.rs new file mode 100644 index 00000000000..4fe1113699c --- /dev/null +++ b/rs/kio/macros/tests/machine.rs @@ -0,0 +1,194 @@ +//! How a `#[kio::machine]` runs: where it resumes, what each call re-runs, and when +//! its stored locals drop. + +use std::{ + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + task::Poll, +}; + +/// Counts its drops. +struct Guard(Arc); + +impl Drop for Guard { + fn drop(&mut self) { + self.0.fetch_add(1, Ordering::Relaxed); + } +} + +struct Steps { + values: kio::Queue, + polls: usize, + bail: bool, + drops: Arc, + state: StepsState, +} + +#[kio::machine(self.state: StepsState)] +impl Steps { + fn new(values: &kio::Queue) -> Self { + Self { + values: values.clone(), + polls: 0, + bail: false, + drops: Arc::default(), + state: StepsState::Start, + } + } + + fn poll_steps(&mut self, waiter: &kio::Waiter) -> Poll> { + #[every_poll] + self.polls += 1; + + let guard: Guard = Guard(self.drops.clone()); + let first: u64 = wait!(First => self.values.poll_pop(waiter))?; + if first == 0 { + return Poll::Ready(Ok(0)); + } + let mut total: u64 = first; + // Leaves the machine at the wait, and runs again on the next call. + let second = wait!(Second => { + if self.bail { + return Poll::Ready(Ok(100)); + } + self.values.poll_pop(waiter) + })?; + // The guard's last use, so it drops on leaving this wait. + drop(guard); + total += second; + wait!(Third => self.values.poll_pop(waiter).map_ok(|third| *total += third))?; + Poll::Ready(Ok(total)) + } +} + +#[test] +fn resumes_at_each_wait() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + let waiter = kio::Waiter::noop(); + assert_eq!(steps.state.name(), "Start"); + + assert!(steps.poll_steps(&waiter).is_pending()); + assert_eq!(steps.state.name(), "First"); + assert!(steps.poll_steps(&waiter).is_pending()); + assert_eq!(steps.polls, 2); + + values.try_push(1).unwrap(); + assert!(steps.poll_steps(&waiter).is_pending()); + assert_eq!(steps.state.name(), "Second"); + assert_eq!(steps.drops.load(Ordering::Relaxed), 0); + + values.try_push(2).unwrap(); + assert!(steps.poll_steps(&waiter).is_pending()); + assert_eq!(steps.state.name(), "Third"); + assert_eq!(steps.drops.load(Ordering::Relaxed), 1); + + values.try_push(3).unwrap(); + assert_eq!(steps.poll_steps(&waiter), Poll::Ready(Ok(6))); + assert_eq!(steps.state.name(), "Done"); + assert_eq!(steps.polls, 5); +} + +#[test] +fn returns_early_from_run_once_code() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + values.try_push(0).unwrap(); + assert_eq!(steps.poll_steps(&kio::Waiter::noop()), Poll::Ready(Ok(0))); + assert_eq!(steps.state.name(), "Done"); + assert_eq!(steps.drops.load(Ordering::Relaxed), 1); +} + +#[test] +fn returns_from_a_wait() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + values.try_push(1).unwrap(); + steps.bail = true; + assert_eq!(steps.poll_steps(&kio::Waiter::noop()), Poll::Ready(Ok(100))); + // A `return` inside the poll leaves the machine where it was. + assert_eq!(steps.state.name(), "Second"); +} + +#[test] +fn propagates_errors() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + values.close(); + assert_eq!(steps.poll_steps(&kio::Waiter::noop()), Poll::Ready(Err(kio::Closed))); + assert_eq!(steps.state.name(), "Done"); + assert_eq!(steps.drops.load(Ordering::Relaxed), 1); +} + +#[test] +fn drops_stored_locals_when_dropped() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + values.try_push(1).unwrap(); + assert!(steps.poll_steps(&kio::Waiter::noop()).is_pending()); + assert_eq!(steps.state.name(), "Second"); + + let drops = steps.drops.clone(); + drop(steps); + assert_eq!(drops.load(Ordering::Relaxed), 1); +} + +#[test] +#[should_panic(expected = "polled after returning `Poll::Ready`")] +fn panics_when_polled_after_ready() { + let values = kio::Queue::new(); + let mut steps = Steps::new(&values); + values.try_push(0).unwrap(); + let waiter = kio::Waiter::noop(); + assert!(steps.poll_steps(&waiter).is_ready()); + let _ = steps.poll_steps(&waiter); +} + +#[test] +fn is_send_when_its_locals_are() { + fn assert_send() {} + assert_send::(); +} + +/// A conditional wait: one that is ready at once when it has nothing to wait for. +struct Maybe { + values: kio::Queue, + state: MaybeState, +} + +#[kio::machine(self.state: MaybeState)] +impl Maybe { + fn poll_maybe(&mut self, waiter: &kio::Waiter) -> Poll> { + let first: u64 = wait!(First => self.values.poll_pop(waiter))?; + let more: bool = first > 1; + let second = wait!(Second => match more { + true => self.values.poll_pop(waiter), + false => Poll::Ready(Ok(0)), + })?; + Poll::Ready(Ok(first + second)) + } +} + +#[test] +fn skips_a_conditional_wait() { + let values = kio::Queue::new(); + let waiter = kio::Waiter::noop(); + + let mut maybe = Maybe { + values: values.clone(), + state: MaybeState::Start, + }; + values.try_push(1).unwrap(); + assert_eq!(maybe.poll_maybe(&waiter), Poll::Ready(Ok(1))); + + let mut maybe = Maybe { + values: values.clone(), + state: MaybeState::Start, + }; + values.try_push(2).unwrap(); + assert!(maybe.poll_maybe(&waiter).is_pending()); + values.try_push(3).unwrap(); + assert_eq!(maybe.poll_maybe(&waiter), Poll::Ready(Ok(5))); +} diff --git a/rs/kio/macros/tests/ui.rs b/rs/kio/macros/tests/ui.rs new file mode 100644 index 00000000000..2d6be9cf1f1 --- /dev/null +++ b/rs/kio/macros/tests/ui.rs @@ -0,0 +1,6 @@ +//! Each mistake in `ui/` and the diagnostic it reports. + +#[test] +fn ui() { + trybuild::TestCases::new().compile_fail("tests/ui/*.rs"); +} diff --git a/rs/kio/macros/tests/ui/branch_wait.rs b/rs/kio/macros/tests/ui/branch_wait.rs new file mode 100644 index 00000000000..bdd7900b848 --- /dev/null +++ b/rs/kio/macros/tests/ui/branch_wait.rs @@ -0,0 +1,23 @@ +// A wait inside a branch. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + let b: u64 = if a > 1 { wait!(B => self.values.poll_pop(waiter))? } else { 0 }; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/branch_wait.stderr b/rs/kio/macros/tests/ui/branch_wait.stderr new file mode 100644 index 00000000000..cdcacdcc515 --- /dev/null +++ b/rs/kio/macros/tests/ui/branch_wait.stderr @@ -0,0 +1,5 @@ +error: `wait!` must start a top-level statement, outside any branch or loop: `let x: T = wait!(Step => poll)?;` + --> ${workspace}/rs/kio/macros/tests/ui/branch_wait.rs:18:27 + | +18 | let b: u64 = if a > 1 { wait!(B => self.values.poll_pop(waiter))? } else { 0 }; + | ^^^^ diff --git a/rs/kio/macros/tests/ui/break_outside_loop.rs b/rs/kio/macros/tests/ui/break_outside_loop.rs new file mode 100644 index 00000000000..20c7d3f09b0 --- /dev/null +++ b/rs/kio/macros/tests/ui/break_outside_loop.rs @@ -0,0 +1,26 @@ +// A `break` that would leave the machine's own resume loop. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + if a > 1 { + break; + } + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/break_outside_loop.stderr b/rs/kio/macros/tests/ui/break_outside_loop.stderr new file mode 100644 index 00000000000..8e61e132043 --- /dev/null +++ b/rs/kio/macros/tests/ui/break_outside_loop.stderr @@ -0,0 +1,5 @@ +error: `break` and `continue` need a loop of their own + --> ${workspace}/rs/kio/macros/tests/ui/break_outside_loop.rs:19:4 + | +19 | break; + | ^^^^^ diff --git a/rs/kio/macros/tests/ui/duplicate_wait.rs b/rs/kio/macros/tests/ui/duplicate_wait.rs new file mode 100644 index 00000000000..ae2dae91ae0 --- /dev/null +++ b/rs/kio/macros/tests/ui/duplicate_wait.rs @@ -0,0 +1,23 @@ +// Two waits with one name. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + let b: u64 = wait!(A => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/duplicate_wait.stderr b/rs/kio/macros/tests/ui/duplicate_wait.stderr new file mode 100644 index 00000000000..6208376e25f --- /dev/null +++ b/rs/kio/macros/tests/ui/duplicate_wait.stderr @@ -0,0 +1,11 @@ +error: a second `wait!(A => ..)` + --> ${workspace}/rs/kio/macros/tests/ui/duplicate_wait.rs:18:22 + | +18 | let b: u64 = wait!(A => self.values.poll_pop(waiter))?; + | ^ + +error: the first is here + --> ${workspace}/rs/kio/macros/tests/ui/duplicate_wait.rs:16:22 + | +16 | let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + | ^ diff --git a/rs/kio/macros/tests/ui/every_poll_late.rs b/rs/kio/macros/tests/ui/every_poll_late.rs new file mode 100644 index 00000000000..1f001b85fd9 --- /dev/null +++ b/rs/kio/macros/tests/ui/every_poll_late.rs @@ -0,0 +1,25 @@ +// An `#[every_poll]` statement after the first run-once one. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + #[every_poll] + let now = 1; + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/every_poll_late.stderr b/rs/kio/macros/tests/ui/every_poll_late.stderr new file mode 100644 index 00000000000..3e0429463a4 --- /dev/null +++ b/rs/kio/macros/tests/ui/every_poll_late.stderr @@ -0,0 +1,5 @@ +error: `#[every_poll]` statements lead the body + --> ${workspace}/rs/kio/macros/tests/ui/every_poll_late.rs:19:3 + | +19 | let now = 1; + | ^^^^^^^^^^^^ diff --git a/rs/kio/macros/tests/ui/generic.rs b/rs/kio/macros/tests/ui/generic.rs new file mode 100644 index 00000000000..c1eb150e812 --- /dev/null +++ b/rs/kio/macros/tests/ui/generic.rs @@ -0,0 +1,18 @@ +// A generic impl. +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a = wait!(A => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(a)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/generic.stderr b/rs/kio/macros/tests/ui/generic.stderr new file mode 100644 index 00000000000..93f5cb3ef26 --- /dev/null +++ b/rs/kio/macros/tests/ui/generic.stderr @@ -0,0 +1,5 @@ +error: #[kio::machine] does not support generic impls + --> ${workspace}/rs/kio/macros/tests/ui/generic.rs:11:5 + | +11 | impl M { + | ^^^ diff --git a/rs/kio/macros/tests/ui/hidden_borrow.rs b/rs/kio/macros/tests/ui/hidden_borrow.rs new file mode 100644 index 00000000000..39804446541 --- /dev/null +++ b/rs/kio/macros/tests/ui/hidden_borrow.rs @@ -0,0 +1,23 @@ +// A borrow behind an elided path lifetime: a known limit, reported as a missing lifetime. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: std::cell::Ref = self.cell.borrow(); + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(*label + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/hidden_borrow.stderr b/rs/kio/macros/tests/ui/hidden_borrow.stderr new file mode 100644 index 00000000000..9bb3e9c42ac --- /dev/null +++ b/rs/kio/macros/tests/ui/hidden_borrow.stderr @@ -0,0 +1,22 @@ +error[E0106]: missing lifetime specifier + --> ${workspace}/rs/kio/macros/tests/ui/hidden_borrow.rs:17:28 + | +17 | let label: std::cell::Ref = self.cell.borrow(); + | ^ expected named lifetime parameter + | +help: consider introducing a named lifetime parameter + | +17 ~ let label: std::cell::Ref<'a, u64> = self.cell.borrow(); +18 ~ let b: u64 = wait!(B<'a> => self.values.poll_pop(waiter))?; + | + +error[E0106]: missing lifetime specifier + --> ${workspace}/rs/kio/macros/tests/ui/hidden_borrow.rs:17:28 + | +17 | let label: std::cell::Ref = self.cell.borrow(); + | ^ expected named lifetime parameter + | +help: consider using the `'__kio` lifetime + | +17 | let label: std::cell::Ref<'__kio, u64> = self.cell.borrow(); + | +++++++ diff --git a/rs/kio/macros/tests/ui/hidden_yield.rs b/rs/kio/macros/tests/ui/hidden_yield.rs new file mode 100644 index 00000000000..122fc46c9f0 --- /dev/null +++ b/rs/kio/macros/tests/ui/hidden_yield.rs @@ -0,0 +1,24 @@ +// Run-once code returns `Poll::Pending` through `ready!`. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + let c = std::task::ready!(self.values.poll_pop(waiter))?; + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/hidden_yield.stderr b/rs/kio/macros/tests/ui/hidden_yield.stderr new file mode 100644 index 00000000000..536b038eab7 --- /dev/null +++ b/rs/kio/macros/tests/ui/hidden_yield.stderr @@ -0,0 +1,5 @@ +error: this statement runs once, so it cannot return `Poll::Pending`: wait with `let x: T = wait!(Step => poll)?;` + --> ${workspace}/rs/kio/macros/tests/ui/hidden_yield.rs:18:22 + | +18 | let c = std::task::ready!(self.values.poll_pop(waiter))?; + | ^^^^^ diff --git a/rs/kio/macros/tests/ui/missing_try.rs b/rs/kio/macros/tests/ui/missing_try.rs new file mode 100644 index 00000000000..c4debdfde31 --- /dev/null +++ b/rs/kio/macros/tests/ui/missing_try.rs @@ -0,0 +1,23 @@ +// A wait's `Result` is used without its `?`. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + let b: u64 = wait!(B => self.values.poll_pop(waiter)); + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/missing_try.stderr b/rs/kio/macros/tests/ui/missing_try.stderr new file mode 100644 index 00000000000..8cb66bcab90 --- /dev/null +++ b/rs/kio/macros/tests/ui/missing_try.stderr @@ -0,0 +1,18 @@ +error[E0308]: mismatched types + --> ${workspace}/rs/kio/macros/tests/ui/missing_try.rs:18:16 + | +13 | #[kio::machine(self.state: MState)] + | ----------------------------------- in this attribute macro expansion +... +18 | let b: u64 = wait!(B => self.values.poll_pop(waiter)); + | --- ^^^^ expected `u64`, found `Result` + | | + | expected due to this + | + = note: expected type `u64` + found enum `Result` + = note: this error originates in the attribute macro `kio::machine` (in Nightly builds, run with -Z macro-backtrace for more info) +help: consider using `Result::expect` to unwrap the `Result` value, panicking if the value is a `Result::Err` + | +13 | #[kio::machine(self.state: MState)].expect("REASON") + | +++++++++++++++++ diff --git a/rs/kio/macros/tests/ui/not_send.rs b/rs/kio/macros/tests/ui/not_send.rs new file mode 100644 index 00000000000..0c1c9ecaeb3 --- /dev/null +++ b/rs/kio/macros/tests/ui/not_send.rs @@ -0,0 +1,27 @@ +// A `!Send` local kept across a wait, in a machine that must be `Send`. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: std::rc::Rc = std::rc::Rc::new(format!("m-{a}")); + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn assert_send() {} + +fn main() { + assert_send::(); +} diff --git a/rs/kio/macros/tests/ui/not_send.stderr b/rs/kio/macros/tests/ui/not_send.stderr new file mode 100644 index 00000000000..d077a022a2b --- /dev/null +++ b/rs/kio/macros/tests/ui/not_send.stderr @@ -0,0 +1,29 @@ +error[E0277]: `Rc` cannot be sent between threads safely + --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:26:16 + | +26 | assert_send::(); + | ^ `Rc` cannot be sent between threads safely + | + = help: the trait `Send` is not implemented for `Rc` +note: required for `MStateB` to implement `Send` + --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:18:22 + | +17 | let label: std::rc::Rc = std::rc::Rc::new(format!("m-{a}")); + | ----- unsatisfied trait bound introduced here +18 | let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + | ^ +note: required because it appears within the type `MState` + --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:13:28 + | +13 | #[kio::machine(self.state: MState)] + | ^^^^^^ +note: required because it appears within the type `M` + --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:7:8 + | + 7 | struct M { + | ^ +note: required by a bound in `assert_send` + --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:23:19 + | +23 | fn assert_send() {} + | ^^^^ required by this bound in `assert_send` diff --git a/rs/kio/macros/tests/ui/poll_moves.rs b/rs/kio/macros/tests/ui/poll_moves.rs new file mode 100644 index 00000000000..1b7180023a6 --- /dev/null +++ b/rs/kio/macros/tests/ui/poll_moves.rs @@ -0,0 +1,26 @@ +// A wait's poll moves a stored local, which it only borrows. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = format!("m-{a}"); + let b: u64 = wait!(B => { + drop(label); + self.values.poll_pop(waiter) + })?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/poll_moves.stderr b/rs/kio/macros/tests/ui/poll_moves.stderr new file mode 100644 index 00000000000..598a82892a9 --- /dev/null +++ b/rs/kio/macros/tests/ui/poll_moves.stderr @@ -0,0 +1,19 @@ +error: calls to `std::mem::drop` with a reference instead of an owned value does nothing + --> ${workspace}/rs/kio/macros/tests/ui/poll_moves.rs:19:4 + | +19 | drop(label); + | ^^^^^-----^ + | | + | argument has type `&mut String` + | +note: the lint level is defined here + --> ${workspace}/rs/kio/macros/tests/ui/poll_moves.rs:13:1 + | +13 | #[kio::machine(self.state: MState)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: this error originates in the attribute macro `kio::machine` (in Nightly builds, run with -Z macro-backtrace for more info) +help: use `let _ = ...` to ignore the expression or result + | +19 - drop(label); +19 + let _ = label; + | diff --git a/rs/kio/macros/tests/ui/poll_type.rs b/rs/kio/macros/tests/ui/poll_type.rs new file mode 100644 index 00000000000..1f822abe1ae --- /dev/null +++ b/rs/kio/macros/tests/ui/poll_type.rs @@ -0,0 +1,23 @@ +// A type error inside a wait's poll. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop())?; + let label: String = format!("m-{a}"); + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/poll_type.stderr b/rs/kio/macros/tests/ui/poll_type.stderr new file mode 100644 index 00000000000..52f6184795f --- /dev/null +++ b/rs/kio/macros/tests/ui/poll_type.stderr @@ -0,0 +1,15 @@ +error[E0061]: this method takes 1 argument but 0 arguments were supplied + --> ${workspace}/rs/kio/macros/tests/ui/poll_type.rs:16:39 + | + 16 | let a: u64 = wait!(A => self.values.poll_pop())?; + | ^^^^^^^^-- argument #1 of type `&Waiter` is missing + | +note: method defined here + --> ${workspace}/rs/kio/src/queue.rs:185:9 + | +185 | pub fn poll_pop(&self, waiter: &Waiter) -> Poll> { + | ^^^^^^^^ +help: provide the argument + | + 16 | let a: u64 = wait!(A => self.values.poll_pop(/* &Waiter */))?; + | +++++++++++++ diff --git a/rs/kio/macros/tests/ui/segment_type.rs b/rs/kio/macros/tests/ui/segment_type.rs new file mode 100644 index 00000000000..c8c4ea145a2 --- /dev/null +++ b/rs/kio/macros/tests/ui/segment_type.rs @@ -0,0 +1,23 @@ +// A type error in run-once code. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: String = a; + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/segment_type.stderr b/rs/kio/macros/tests/ui/segment_type.stderr new file mode 100644 index 00000000000..58f2e209d7e --- /dev/null +++ b/rs/kio/macros/tests/ui/segment_type.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> ${workspace}/rs/kio/macros/tests/ui/segment_type.rs:17:23 + | +17 | let label: String = a; + | ------ ^ expected `String`, found `u64` + | | + | expected due to this + | +help: try using a conversion method + | +17 | let label: String = a.to_string(); + | ++++++++++++ diff --git a/rs/kio/macros/tests/ui/self_borrow.rs b/rs/kio/macros/tests/ui/self_borrow.rs new file mode 100644 index 00000000000..2ee78eb1f49 --- /dev/null +++ b/rs/kio/macros/tests/ui/self_borrow.rs @@ -0,0 +1,23 @@ +// A borrow of the machine kept across a wait. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: &kio::Queue = &self.values; + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/self_borrow.stderr b/rs/kio/macros/tests/ui/self_borrow.stderr new file mode 100644 index 00000000000..995b529510e --- /dev/null +++ b/rs/kio/macros/tests/ui/self_borrow.stderr @@ -0,0 +1,5 @@ +error: `label` lives across `wait!(B => ..)`, so it is stored in `MState::B`, which cannot hold a borrow: store an owned value, or borrow again inside the wait + --> ${workspace}/rs/kio/macros/tests/ui/self_borrow.rs:17:14 + | +17 | let label: &kio::Queue = &self.values; + | ^ diff --git a/rs/kio/macros/tests/ui/untyped.rs b/rs/kio/macros/tests/ui/untyped.rs new file mode 100644 index 00000000000..45da9c136fd --- /dev/null +++ b/rs/kio/macros/tests/ui/untyped.rs @@ -0,0 +1,23 @@ +// A local kept across a wait has no type. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label = format!("m-{a}"); + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/untyped.stderr b/rs/kio/macros/tests/ui/untyped.stderr new file mode 100644 index 00000000000..a0d1af6c730 --- /dev/null +++ b/rs/kio/macros/tests/ui/untyped.stderr @@ -0,0 +1,5 @@ +error: `label` lives across `wait!(B => ..)`, so it is stored in `MState::B`: give it a type, `let label: Type` + --> ${workspace}/rs/kio/macros/tests/ui/untyped.rs:17:7 + | +17 | let label = format!("m-{a}"); + | ^^^^^ diff --git a/rs/kio/macros/tests/ui/wrong_annotation.rs b/rs/kio/macros/tests/ui/wrong_annotation.rs new file mode 100644 index 00000000000..eb478ce63fb --- /dev/null +++ b/rs/kio/macros/tests/ui/wrong_annotation.rs @@ -0,0 +1,23 @@ +// A stored local's annotation disagrees with its value. +#![allow(dead_code)] + +#[allow(unused_imports, reason = "a rejected impl expands to nothing")] +use std::task::Poll; + +struct M { + values: kio::Queue, + cell: std::cell::RefCell, + state: MState, +} + +#[kio::machine(self.state: MState)] +impl M { + fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + let a: u64 = wait!(A => self.values.poll_pop(waiter))?; + let label: u32 = format!("m-{a}"); + let b: u64 = wait!(B => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(label.len() as u64 + a + b)) + } +} + +fn main() {} diff --git a/rs/kio/macros/tests/ui/wrong_annotation.stderr b/rs/kio/macros/tests/ui/wrong_annotation.stderr new file mode 100644 index 00000000000..034c74abe09 --- /dev/null +++ b/rs/kio/macros/tests/ui/wrong_annotation.stderr @@ -0,0 +1,17 @@ +error[E0308]: mismatched types + --> ${workspace}/rs/kio/macros/tests/ui/wrong_annotation.rs:17:20 + | +17 | let label: u32 = format!("m-{a}"); + | ^^^^^^^^^^^^^^^^ expected `u32`, found `String` + +error[E0599]: no method named `len` found for type `u32` in the current scope + --> ${workspace}/rs/kio/macros/tests/ui/wrong_annotation.rs:19:24 + | +19 | Poll::Ready(Ok(label.len() as u64 + a + b)) + | ^^^ + | +help: there is a method `le` with a similar name, but with different arguments + --> $RUST/core/src/cmp.rs + | + | fn le(&self, other: &Rhs) -> bool { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/rs/kio/src/lib.rs b/rs/kio/src/lib.rs index d16fe864b9e..6679fc56128 100644 --- a/rs/kio/src/lib.rs +++ b/rs/kio/src/lib.rs @@ -52,6 +52,9 @@ mod loom; #[cfg(all(test, not(loom)))] mod tests; +#[cfg(feature = "macros")] +pub use kio_macros::machine; + pub use bridge::Bridge; pub use consumer::Consumer; pub use lock::{Lock, LockGuard}; diff --git a/rs/moq-net/Cargo.toml b/rs/moq-net/Cargo.toml index c1f3db3b832..a9050fa1bf2 100644 --- a/rs/moq-net/Cargo.toml +++ b/rs/moq-net/Cargo.toml @@ -34,7 +34,7 @@ flate2 = { workspace = true, features = ["zlib-rs", "runtime_detection"] } futures = { workspace = true, optional = true } hashbrown = { workspace = true } hashlink = { workspace = true } -kio = { workspace = true } +kio = { workspace = true, features = ["macros"] } moq-clock = { version = "0.11.0", path = "../moq-clock", default-features = false } moq-pattern = { workspace = true, features = ["serde"] } num_enum = { workspace = true } diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index c4d32173d53..5763cf2e697 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -841,94 +841,81 @@ struct AnnounceServe { state: AnnounceState, } -#[expect( - clippy::large_enum_variant, - reason = "a state machine's enum is its storage: one transient instance per stream, so the big variant is the working state, not padding held in bulk" -)] -enum AnnounceState { - /// Reading the ANNOUNCE_REQUEST. - Decode, - /// Waiting on the peer's SETUP for the session-wide excluded origin - /// (lite-05, whose wire carries no per-stream exclude_hop). - ExcludeHop { prefix: crate::Path, hidden: bool }, - /// Streaming announce updates. - Run { - origin: origin::Consumer, - announced: announce::Consumer, - run: AnnounceRun, - }, -} - +#[kio::machine(self.state: AnnounceState)] impl AnnounceServe { fn new(shared: Arc, stream: Stream) -> Self { Self { _withdrawing: shared.withdrawal.register(), shared, stream: Some(stream), - state: AnnounceState::Decode, + state: AnnounceState::Start, } } fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { - loop { - match &mut self.state { - AnnounceState::Decode => { - let stream = self.stream.as_mut().expect("stream present"); - let interest = ready!(stream.reader.poll_decode::(waiter))?; - let prefix = interest.prefix.clone(); - let hidden = interest.hidden; - - // The identity whose routes we filter out. Lite-04/05 carry it per - // announce stream; lite-06+ reads the session-wide SETUP Hop - // parameter, the same identity the subscribe path excludes. A peer that - // declares nothing falls back to the identity the session assigned it. - let assigned = self.shared.peer_hop.unwrap_or(Hop::UNKNOWN); - if self.shared.version.has_exclude_hop() { - let exclude_hop = match interest.exclude_hop { - Hop::UNKNOWN => assigned, - hop => hop, - }; - self.start(prefix, exclude_hop, hidden); - } else if self.shared.version.has_setup_stream() { - self.state = AnnounceState::ExcludeHop { prefix, hidden }; - } else { - self.start(prefix, assigned, hidden); - } - } - AnnounceState::ExcludeHop { prefix, hidden } => { - let assigned = self.shared.peer_hop.unwrap_or(Hop::UNKNOWN); - let exclude_hop = ready!(self.shared.peer_setup.poll_hop(waiter)).unwrap_or(assigned); - let (prefix, hidden) = (prefix.clone(), *hidden); - self.start(prefix, exclude_hop, hidden); - } - AnnounceState::Run { origin, announced, run } => { - let stream = self.stream.as_mut().expect("stream present"); - if self.shared.withdrawal.poll(waiter).is_ready() { - run.withdraw(stream, origin, announced)?; + // Reading the ANNOUNCE_REQUEST. + let interest = wait!(Decode => { + let stream = self.stream.as_mut().expect("stream present"); + stream.reader.poll_decode::(waiter) + })?; + let prefix: crate::Path = interest.prefix.clone(); + let hidden: bool = interest.hidden; + + // The identity whose routes we filter out. Lite-04/05 carry it per + // announce stream; lite-06+ reads the session-wide SETUP Hop + // parameter, the same identity the subscribe path excludes. A peer that + // declares nothing falls back to the identity the session assigned it. + let assigned: Hop = self.shared.peer_hop.unwrap_or(Hop::UNKNOWN); + let exclude_hop: Option = match self.shared.version.has_exclude_hop() { + true => Some(match interest.exclude_hop { + Hop::UNKNOWN => assigned, + hop => hop, + }), + // Waits on the peer's SETUP below (lite-05, whose wire carries no + // per-stream exclude_hop). + false if self.shared.version.has_setup_stream() => None, + false => Some(assigned), + }; + let exclude_hop = wait!(ExcludeHop => match exclude_hop { + Some(hop) => Poll::Ready(*hop), + None => self.shared.peer_setup.poll_hop(waiter).map(|hop| hop.unwrap_or(*assigned)), + }); + let (origin, announced, run): (origin::Consumer, announce::Consumer, AnnounceRun) = + self.start(prefix, exclude_hop, hidden); + + // Streaming announce updates. + wait!(Run => { + let stream = self.stream.as_mut().expect("stream present"); + if self.shared.withdrawal.poll(waiter).is_ready() { + run.withdraw(stream, origin, announced)?; + } + let res = ready!(run.poll(stream, origin, announced, waiter)); + if let Err(err) = res { + match &err { + Error::Cancel + | Error::Stream(crate::StreamError::Cancel) + | Error::Session(crate::SessionError::Cancel) + | Error::Transport(_) + | Error::IdleTimeout => { + tracing::debug!(prefix = %origin.root(), "announcing cancelled"); } - let res = ready!(run.poll(stream, origin, announced, waiter)); - if let Err(err) = res { - match &err { - Error::Cancel - | Error::Stream(crate::StreamError::Cancel) - | Error::Session(crate::SessionError::Cancel) - | Error::Transport(_) - | Error::IdleTimeout => { - tracing::debug!(prefix = %origin.root(), "announcing cancelled"); - } - err => { - tracing::warn!(%err, prefix = %origin.root(), "announcing error"); - } - } - self.stream.take().expect("stream present").writer.abort(&err); + err => { + tracing::warn!(%err, prefix = %origin.root(), "announcing error"); } - return Poll::Ready(Ok(())); } + self.stream.take().expect("stream present").writer.abort(&err); } - } + Poll::Ready(()) + }); + Poll::Ready(Ok(())) } - fn start(&mut self, prefix: crate::Path, exclude_hop: Hop, hidden: bool) { + fn start( + &self, + prefix: crate::Path, + exclude_hop: Hop, + hidden: bool, + ) -> (origin::Consumer, announce::Consumer, AnnounceRun) { // If the requested prefix is outside our scope (an empty origin, or a token // that doesn't grant it), we simply have nothing to announce. Respond with an // empty set and keep the stream open (the subscriber treats a FIN here as a @@ -969,7 +956,7 @@ impl AnnounceServe { run.prefix.clone(), crate::auth::Direction::Publish, )); - self.state = AnnounceState::Run { origin, announced, run }; + (origin, announced, run) } } diff --git a/rs/moq-net/src/lite/session.rs b/rs/moq-net/src/lite/session.rs index 6dfc3947083..1e44f6d9612 100644 --- a/rs/moq-net/src/lite/session.rs +++ b/rs/moq-net/src/lite/session.rs @@ -749,33 +749,20 @@ fn poll_session_stream(stream: &mut Stream, waiter: &kio::Wa struct SendSetup { stats: crate::stats::Session, version: Version, + session: Transport, + setup: Box, state: SendSetupState, } -enum SendSetupState { - /// Waiting for stream credit on our own session handle. - Open { - session: Transport, - setup: Box, - }, - /// Flushing the buffered SETUP, then FIN and wait for the acknowledgement (a - /// reset racing the FIN would discard the unacked message). - Send { - writer: Writer, - finished: bool, - }, - Done, -} - +#[kio::machine(self.state: SendSetupState)] impl SendSetup { fn new(session: Transport, setup: Setup, version: Version, stats: crate::stats::Session) -> Self { Self { stats, version, - state: SendSetupState::Open { - session, - setup: Box::new(setup), - }, + session, + setup: Box::new(setup), + state: SendSetupState::Start, } } @@ -784,35 +771,22 @@ impl SendSetup { Ok(()) => {} Err(err) => tracing::debug!(%err, "failed to send setup"), } - self.state = SendSetupState::Done; Poll::Ready(()) } fn poll_send(&mut self, waiter: &kio::Waiter) -> Poll> { - loop { - match &mut self.state { - SendSetupState::Open { session, setup } => { - let stream = ready!(session.poll_open_uni(waiter, Default::default())) - .map_err(crate::lite::error::from_transport)?; - let mut writer = Writer::new(stream, self.version).with_stats(&self.stats); - writer.buffer(&super::DataType::Setup)?; - writer.buffer(&**setup)?; - self.state = SendSetupState::Send { - writer, - finished: false, - }; - } - SendSetupState::Send { writer, finished } => { - if !*finished { - ready!(writer.poll_flush(waiter))?; - writer.finish()?; - *finished = true; - } - return writer.poll_closed(waiter); - } - SendSetupState::Done => return Poll::Ready(Ok(())), - } - } + // Waiting for stream credit on our own session handle. + let stream = wait!(Open => self.session.poll_open_uni(waiter, Default::default())) + .map_err(crate::lite::error::from_transport)?; + let mut writer: Writer = + Writer::new(stream, self.version).with_stats(&self.stats); + writer.buffer(&super::DataType::Setup)?; + writer.buffer(&*self.setup)?; + // Flushing the buffered SETUP, then FIN and wait for the acknowledgement (a + // reset racing the FIN would discard the unacked message). + wait!(Flush => writer.poll_flush(waiter))?; + writer.finish()?; + Poll::Ready(wait!(Close => writer.poll_closed(waiter))) } } @@ -828,18 +802,7 @@ struct SendGoaway { state: SendGoawayState, } -enum SendGoawayState { - Waiting, - Open { - payload: crate::goaway::Goaway, - }, - /// Keep the writer through FIN acknowledgement, since dropping it resets the stream. - Send { - stream: Stream, - finished: bool, - }, -} - +#[kio::machine(self.state: SendGoawayState)] impl SendGoaway { fn new( session: Transport, @@ -853,73 +816,55 @@ impl SendGoaway { goaway, closed: session.clone(), session, - state: SendGoawayState::Waiting, + state: SendGoawayState::Start, } } fn poll(&mut self, waiter: &kio::Waiter) -> Poll<()> { - loop { - if self.closed.poll_closed(waiter).is_ready() { + #[every_poll] + if self.closed.poll_closed(waiter).is_ready() { + return Poll::Ready(()); + } + + let payload: crate::goaway::Goaway = match wait!(Trigger => self.goaway.poll_triggered(waiter)) { + Some(payload) => payload, + None => return Poll::Ready(()), + }; + if !self.version.has_goaway() { + return Poll::Ready(()); + } + let mut stream: Stream = match wait!(Open => Stream::poll_open(&self.session, self.version, waiter)) + { + Ok(stream) => stream, + Err(err) => { + tracing::warn!(%err, "failed to send goaway"); return Poll::Ready(()); } - match &mut self.state { - SendGoawayState::Waiting => { - let Some(payload) = ready!(self.goaway.poll_triggered(waiter)) else { - return Poll::Ready(()); - }; - if !self.version.has_goaway() { - return Poll::Ready(()); - } - self.state = SendGoawayState::Open { payload }; - } - SendGoawayState::Open { payload } => { - let mut stream = match ready!(Stream::poll_open(&self.session, self.version, waiter)) { - Ok(stream) => stream, - Err(err) => { - tracing::warn!(%err, "failed to send goaway"); - return Poll::Ready(()); - } - }; - stream = stream.with_stats(&self.stats); - let msg = super::Goaway { - uri: std::borrow::Cow::Borrowed(payload.uri.as_str()), - }; - if let Err(err) = stream - .writer - .buffer(&super::ControlType::Goaway) - .and_then(|()| stream.writer.buffer(&msg)) - { - tracing::warn!(%err, "failed to send goaway"); - return Poll::Ready(()); - } - self.state = SendGoawayState::Send { - stream, - finished: false, - }; - } - SendGoawayState::Send { stream, finished } => { - let result = if !*finished { - match ready!(stream.writer.poll_flush(waiter)) { - Ok(()) => { - *finished = true; - stream.writer.finish() - } - Err(err) => Err(err), - } - } else { - Ok(()) - }; - let result = match result { - Ok(()) => ready!(stream.writer.poll_closed(waiter)), - Err(err) => Err(err), - }; - if let Err(err) = result { - tracing::warn!(%err, "failed to send goaway"); - } - return Poll::Ready(()); - } - } + }; + stream = stream.with_stats(&self.stats); + let msg = super::Goaway { + uri: std::borrow::Cow::Borrowed(payload.uri.as_str()), + }; + if let Err(err) = stream + .writer + .buffer(&super::ControlType::Goaway) + .and_then(|()| stream.writer.buffer(&msg)) + { + tracing::warn!(%err, "failed to send goaway"); + return Poll::Ready(()); } + + // Keep the writer through FIN acknowledgement, since dropping it resets the stream. + let finished: Result<(), Error> = + wait!(Flush => stream.writer.poll_flush(waiter)).and_then(|()| stream.writer.finish()); + let closed = wait!(Close => match finished { + Ok(()) => stream.writer.poll_closed(waiter), + Err(_) => Poll::Ready(Ok(())), + }); + if let Err(err) = finished.and(closed) { + tracing::warn!(%err, "failed to send goaway"); + } + Poll::Ready(()) } } diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 164e88ef9e8..8a2507ebbfb 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -936,163 +936,124 @@ impl Drop for SetupWait { } } -#[expect( - clippy::large_enum_variant, - reason = "a state machine's enum is its storage: one transient instance per stream, so the big variant is the working state, not padding held in bulk" -)] -enum GroupRecvState { - /// Reading the GROUP header. - Header, - /// Filling the group, bailing if the track or group dies first. - Serve { - /// Guarded: dropping this machine mid-group is a cancellation, not a clean end. - group: crate::recv::Group, - track: track::Producer, - ingest: FrameIngest, - _reading: Reading, - }, - Done, -} - +#[kio::machine(self.state: GroupRecvState)] impl GroupRecv { fn new(subscriber: Subscriber, reader: Reader) -> Self { Self { subscriber, reader, - state: GroupRecvState::Header, + state: GroupRecvState::Start, setup_wait: None, } } fn poll_serve(&mut self, waiter: &kio::Waiter) -> Poll> { - loop { - match &mut self.state { - GroupRecvState::Header => { - // Before the header, which a wait after it would lose. - let Poll::Ready(ietf) = self.subscriber.peer_setup.poll_ietf(waiter) else { - let waits = &self.subscriber.setup_waits; - self.setup_wait.get_or_insert_with(|| SetupWait::new(waits)); - return Poll::Pending; - }; - self.setup_wait = None; - let hdr = ready!(self.reader.poll_decode::(waiter))?; - - let (group, track, framing, reading) = { - let mut subs = self.subscriber.subscribes.lock(); - let entry = subs.get_mut(&hdr.subscribe).ok_or(Error::Cancel)?; - - let group_info = group::Info { sequence: hdr.sequence }; - // Stats (groups/frames/bytes) are counted in the model as the group - // is written, through the tagged `track::Producer`. The track counts - // it as content once its first frame lands. - let received = entry.producer.create_group_at(group_info, hdr.frame_start); - // The subscription's end waits until this stream is read. Counted - // whatever the cache said, since the publisher counts every stream it - // opens (a resubscribe resends a cached group), and only after the - // cache holds the group, so a fetch held for the feed that sees it - // accounted also finds it. - let reading = Reading::open(&entry.tail, Some(hdr.sequence), self.subscriber.runtime.now()); - // A route's first group says where its live feed is, when its answer does - // not: even one the cache already holds, as an idle copy asked from its - // head gets back. The copy goes live once the cache shows that group. - // Lite-07's answer does, and a group can overtake it: on a descending - // track the first to land is the newest, not where the feed starts. - if !entry.producer.is_live() && !self.subscriber.version.has_largest() { - entry.producer.set_live( - Some(Position { - group: hdr.sequence, - frame: hdr.frame_start, - }), - None, - ); - } - let group = match received { - Ok(group) => group, - // The group is at or past the end the publisher declared, which no - // later stream can repair. Before lite-05 only a local finish sets - // an end, and lite-05 specified an inclusive one, so its last - // group lands on it: drop only that stream there. - Err(Error::Closed) - if !matches!( - self.subscriber.version, - Version::Lite01 - | Version::Lite02 | Version::Lite03 - | Version::Lite04 | Version::Lite05 - ) => - { - tracing::warn!(group = hdr.sequence, "group past the declared end of track"); - let _ = entry.producer.clone().abort(Error::ProtocolViolation); - return Poll::Ready(Err(Error::ProtocolViolation)); - } - Err(err) => return Poll::Ready(Err(err)), - }; - (group, entry.producer.clone(), entry.framing, reading) - }; - let (priority, order) = track - .subscription() - .map_or((0, Default::default()), |sub| (sub.priority, sub.order)); - self.reader - .set_priority(crate::priority::recv_group(priority, hdr.sequence, order)); - - // The timescale came from TRACK_INFO (read before this subscription was - // even registered), so frames decode immediately. No SUBSCRIBE_OK to - // wait on. - self.state = GroupRecvState::Serve { - group: crate::recv::Group::new(group), - track, - ingest: FrameIngest::new(framing, self.subscriber.version, ietf, hdr.frame_start), - _reading: reading, - }; - } - GroupRecvState::Serve { - group, track, ingest, .. - } => { - // The track or group dying cancels the stream; the peer's own close - // arrives through the ingest's reads. - let res = 'serve: { - if let Poll::Ready(err) = track.poll_aborted(waiter) { - break 'serve Err(err); - } - if let Poll::Ready(err) = group.handle().poll_aborted(waiter) { - break 'serve Err(err); - } - match ingest.poll(&mut self.reader, group, waiter) { - Poll::Ready(res) => break 'serve res, - Poll::Pending => return Poll::Pending, - } - }; + let (ietf, hdr) = wait!(Header => { + // Before the header, which a wait after it would lose. + let Poll::Ready(ietf) = self.subscriber.peer_setup.poll_ietf(waiter) else { + let waits = &self.subscriber.setup_waits; + self.setup_wait.get_or_insert_with(|| SetupWait::new(waits)); + return Poll::Pending; + }; + self.setup_wait = None; + self.reader.poll_decode::(waiter).map_ok(|hdr| (ietf, hdr)) + })?; - // Held until the group settles below, so a frame the track or group cut - // short drops into an already-aborted group instead of reporting a loss. - let GroupRecvState::Serve { - group, - ingest: _ingest, - _reading, - .. - } = std::mem::replace(&mut self.state, GroupRecvState::Done) - else { - unreachable!() - }; - let res = match res { - Ok(()) => { - let _ = group.finish(); - Ok(()) - } - Err(err @ (Error::Cancel | Error::Stream(crate::StreamError::Cancel))) => { - let _ = group.abort(err); - Ok(()) - } - Err(err) => { - tracing::debug!(%err, group = %group.sequence, "group error"); - let _ = group.abort(err.clone()); - Err(err) - } - }; - return Poll::Ready(res); + let (group, track, framing, reading) = { + let mut subs = self.subscriber.subscribes.lock(); + let entry = subs.get_mut(&hdr.subscribe).ok_or(Error::Cancel)?; + + let group_info = group::Info { sequence: hdr.sequence }; + // Stats (groups/frames/bytes) are counted in the model as the group + // is written, through the tagged `track::Producer`. The track counts + // it as content once its first frame lands. + let received = entry.producer.create_group_at(group_info, hdr.frame_start); + // The subscription's end waits until this stream is read. Counted + // whatever the cache said, since the publisher counts every stream it + // opens (a resubscribe resends a cached group), and only after the + // cache holds the group, so a fetch held for the feed that sees it + // accounted also finds it. + let reading = Reading::open(&entry.tail, Some(hdr.sequence), self.subscriber.runtime.now()); + // A route's first group says where its live feed is, when its answer does + // not: even one the cache already holds, as an idle copy asked from its + // head gets back. The copy goes live once the cache shows that group. + // Lite-07's answer does, and a group can overtake it: on a descending + // track the first to land is the newest, not where the feed starts. + if !entry.producer.is_live() && !self.subscriber.version.has_largest() { + entry.producer.set_live( + Some(Position { + group: hdr.sequence, + frame: hdr.frame_start, + }), + None, + ); + } + let group = match received { + Ok(group) => group, + // The group is at or past the end the publisher declared, which no + // later stream can repair. Before lite-05 only a local finish sets + // an end, and lite-05 specified an inclusive one, so its last + // group lands on it: drop only that stream there. + Err(Error::Closed) + if !matches!( + self.subscriber.version, + Version::Lite01 | Version::Lite02 | Version::Lite03 | Version::Lite04 | Version::Lite05 + ) => + { + tracing::warn!(group = hdr.sequence, "group past the declared end of track"); + let _ = entry.producer.clone().abort(Error::ProtocolViolation); + return Poll::Ready(Err(Error::ProtocolViolation)); } - GroupRecvState::Done => return Poll::Ready(Ok(())), + Err(err) => return Poll::Ready(Err(err)), + }; + (group, entry.producer.clone(), entry.framing, reading) + }; + let (priority, order) = track + .subscription() + .map_or((0, Default::default()), |sub| (sub.priority, sub.order)); + self.reader + .set_priority(crate::priority::recv_group(priority, hdr.sequence, order)); + + // The timescale came from TRACK_INFO (read before this subscription was + // even registered), so frames decode immediately. No SUBSCRIBE_OK to + // wait on. + // Guarded: dropping this machine mid-group is a cancellation, not a clean end. + let group: crate::recv::Group = crate::recv::Group::new(group); + let track: track::Producer = track; + let ingest: FrameIngest = FrameIngest::new(framing, self.subscriber.version, ietf, hdr.frame_start); + let reading: Reading = reading; + + // Filling the group, bailing if the track or group dies first. The track or group + // dying cancels the stream; the peer's own close arrives through the ingest's reads. + let res = wait!(Serve => { + if let Poll::Ready(err) = track.poll_aborted(waiter) { + Poll::Ready(Err(err)) + } else if let Poll::Ready(err) = group.handle().poll_aborted(waiter) { + Poll::Ready(Err(err)) + } else { + ingest.poll(&mut self.reader, group, waiter) } - } + }); + + let res = match res { + Ok(()) => { + let _ = group.finish(); + Ok(()) + } + Err(err @ (Error::Cancel | Error::Stream(crate::StreamError::Cancel))) => { + let _ = group.abort(err); + Ok(()) + } + Err(err) => { + tracing::debug!(%err, group = %group.sequence, "group error"); + let _ = group.abort(err.clone()); + Err(err) + } + }; + // Held until the group settles above, so a frame the track or group cut short + // drops into an already-aborted group instead of reporting a loss. + drop((ingest, reading)); + Poll::Ready(res) } } @@ -1497,53 +1458,37 @@ struct ProbeStream { state: ProbeState, } -enum ProbeState { - Open, - Send { stream: Stream }, - Read { stream: Stream }, -} - +#[kio::machine(self.state: ProbeState)] impl ProbeStream { fn new(subscriber: &Subscriber) -> Self { Self { subscriber: subscriber.clone(), session: subscriber.session.clone(), - state: ProbeState::Open, + state: ProbeState::Start, } } fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { - loop { - match &mut self.state { - ProbeState::Open => { - // Probe is best-effort telemetry; a session that is going away - // has no use for a new estimate, so skip it rather than erroring. - if self.subscriber.going_away.is_set() { - return Poll::Ready(Ok(())); - } - let mut stream = ready!(Stream::poll_open(&self.session, self.subscriber.version, waiter))?; - stream = stream.with_stats(self.subscriber.origin.stats()); - stream.writer.buffer(&lite::ControlType::Probe)?; - self.state = ProbeState::Send { stream }; - } - ProbeState::Send { stream } => { - ready!(stream.writer.poll_flush(waiter))?; - let ProbeState::Send { stream } = std::mem::replace(&mut self.state, ProbeState::Open) else { - unreachable!() - }; - self.state = ProbeState::Read { stream }; - } - ProbeState::Read { stream } => { - let bandwidth = self.subscriber.recv_bandwidth.as_ref().expect("gated by RecvBandwidth"); - loop { - let Some(probe) = ready!(stream.reader.poll_decode_maybe::(waiter))? else { - return Poll::Ready(Ok(())); - }; - bandwidth.set(probe.bitrate.map(bandwidth::Rate::from_bps))?; - } - } + let mut stream: Stream = wait!(Open => { + // Probe is best-effort telemetry; a session that is going away + // has no use for a new estimate, so skip it rather than erroring. + if self.subscriber.going_away.is_set() { + return Poll::Ready(Ok(())); } - } + Stream::poll_open(&self.session, self.subscriber.version, waiter) + })? + .with_stats(self.subscriber.origin.stats()); + stream.writer.buffer(&lite::ControlType::Probe)?; + wait!(Send => stream.writer.poll_flush(waiter))?; + Poll::Ready(wait!(Read => { + let bandwidth = self.subscriber.recv_bandwidth.as_ref().expect("gated by RecvBandwidth"); + loop { + let Some(probe) = ready!(stream.reader.poll_decode_maybe::(waiter))? else { + break Poll::Ready(Ok(())); + }; + bandwidth.set(probe.bitrate.map(bandwidth::Rate::from_bps))?; + } + })) } } @@ -1560,33 +1505,7 @@ struct AnnouncePrefix { snapshot: Option, } -enum PrefixState { - /// Opening the control stream (after the GOAWAY gate). - Open, - /// Flushing the buffered request. - Send { stream: Stream }, - /// Lite05+: reading the publisher's ANNOUNCE_OK. - ReadOk { stream: Stream }, - /// Waiting for the link cost (may block on the peer's SETUP). - Cost { - stream: Stream, - responder_origin: Option, - /// Lite05+: the ANNOUNCE_STARTs the publisher counted into its initial set. - initial: u64, - }, - /// Lite01/02: reading the ANNOUNCE_INIT set. - ReadInit { - stream: Stream, - run: PrefixRun, - }, - /// Streaming announce updates. - Run { - stream: Stream, - run: PrefixRun, - }, -} - -/// The announce-decode loop's state, split out so the states above can share it. +/// The announce-decode loop's state. struct PrefixRun { responder_origin: Option, /// What we charge every announcement arriving on this stream. Resolved once: @@ -1606,6 +1525,7 @@ struct PrefixRun { initial: u64, } +#[kio::machine(self.state: PrefixState)] impl AnnouncePrefix { /// `snapshot` was taken when the prefix was first wanted, so a consumer of the /// origin never reads as synced before the request even goes out. @@ -1613,7 +1533,7 @@ impl AnnouncePrefix { Self { subscriber, prefix, - state: PrefixState::Open, + state: PrefixState::Start, snapshot: Some(snapshot), } } @@ -1626,197 +1546,163 @@ impl AnnouncePrefix { } fn poll_run(&mut self, waiter: &kio::Waiter) -> Poll> { - loop { - match &mut self.state { - PrefixState::Open => { - let mut stream = ready!(Stream::poll_open_request( - &self.subscriber.session, - self.subscriber.version, - waiter - ))?; - - stream = stream.with_stats(self.subscriber.origin.stats()); - - stream.writer.buffer(&lite::ControlType::Announce)?; - // Lite04/05: ask the peer to filter out announces that already passed - // through us, so the reflected ones never hit the wire. Encoding drops - // this on every other version, where start_announce below is the only - // filter. - // Hidden routes are requested too: the session mirrors the peer into - // the origin, and each local reader opts in on its own - // (`origin::Consumer::with_hidden`). - stream.writer.buffer(&lite::AnnounceRequest { - prefix: self.prefix.clone(), - exclude_hop: self.subscriber.self_origin, - hidden: true, - })?; - self.state = PrefixState::Send { stream }; - } - PrefixState::Send { stream } => { - ready!(stream.writer.poll_flush(waiter))?; - let PrefixState::Send { stream } = std::mem::replace(&mut self.state, PrefixState::Open) else { - unreachable!() - }; - let version = self.subscriber.version; - // Lite03/04 mark no initial set, so the request going out is the best - // boundary. Lite01/02 use ANNOUNCE_INIT, lite05/06 a count, lite07 SYNCED. - if !version.has_announce_ok() && !matches!(version, Version::Lite01 | Version::Lite02) { - self.snapshot = None; - } - self.state = match version.has_announce_ok() { - true => PrefixState::ReadOk { stream }, - false => PrefixState::Cost { - stream, - responder_origin: None, - initial: 0, - }, - }; - } - PrefixState::ReadOk { stream } => { - // Lite05+: the publisher reports its own origin id, which we stamp onto - // every received Announce's hop chain since it no longer does so itself. - // Lite05/06 mark the initial set by count; lite07 waits for SYNCED. - let ok = ready!(stream.reader.poll_decode::(waiter))?; - if ok.active == 0 && !self.subscriber.version.has_synced() { - self.snapshot = None; - } - // A peer may legally report id 0 (no identity). Keep it: the assigned - // identity stays on `via` and is never forwarded as a hop. - let origin = ok.origin; - let PrefixState::ReadOk { stream } = std::mem::replace(&mut self.state, PrefixState::Open) else { - unreachable!() - }; - self.state = PrefixState::Cost { - stream, - responder_origin: Some(origin), - initial: ok.active, - }; - } - PrefixState::Cost { .. } => { - let link_cost = ready!(self.subscriber.poll_link_cost(waiter)); - let PrefixState::Cost { - stream, - responder_origin, - initial, - } = std::mem::replace(&mut self.state, PrefixState::Open) - else { - unreachable!() - }; + // Opening the control stream (after the GOAWAY gate). + let mut stream: Stream = wait!(Open => Stream::poll_open_request( + &self.subscriber.session, + self.subscriber.version, + waiter + ))? + .with_stats(self.subscriber.origin.stats()); + stream.writer.buffer(&lite::ControlType::Announce)?; + // Lite04/05: ask the peer to filter out announces that already passed + // through us, so the reflected ones never hit the wire. Encoding drops + // this on every other version, where start_announce below is the only + // filter. + // Hidden routes are requested too: the session mirrors the peer into + // the origin, and each local reader opts in on its own + // (`origin::Consumer::with_hidden`). + stream.writer.buffer(&lite::AnnounceRequest { + prefix: self.prefix.clone(), + exclude_hop: self.subscriber.self_origin, + hidden: true, + })?; + wait!(Send => stream.writer.poll_flush(waiter))?; - let run = PrefixRun { - responder_origin, - link_cost, - announced: Announced::new(self.subscriber.announces.clone()), - decoder: lite::AnnounceDecoder::default(), - auth_epoch: 0, - initial, - }; + let version: Version = self.subscriber.version; + // Lite03/04 mark no initial set, so the request going out is the best + // boundary. Lite01/02 use ANNOUNCE_INIT, lite05/06 a count, lite07 SYNCED. + if !version.has_announce_ok() && !matches!(version, Version::Lite01 | Version::Lite02) { + self.snapshot = None; + } - // Lite01/02 send the initial set as one ANNOUNCE_INIT message, so they - // read that before the update stream. Every other version streams it as - // ordinary announces. - self.state = match self.subscriber.version { - Version::Lite01 | Version::Lite02 => PrefixState::ReadInit { stream, run }, - _ => PrefixState::Run { stream, run }, - }; - } - PrefixState::ReadInit { stream, run } => { - // Each suffix takes an announce slot, so a set past what is left of the - // budget is refused before it is decoded. - let version = self.subscriber.version; - let budget = run.announced.slots.available(); - let msg = ready!( - stream - .reader - .poll_decode_with(waiter, |r| lite::AnnounceInit::decode_within(r, version, budget)) - )?; - for suffix in msg.suffixes { - let path = self.prefix.join(&suffix)?; - // Lite01/02 don't carry hop information; the broadcast starts with - // an empty chain and an unpriced link. Stats are attributed in the - // model when this enters the origin via `create_broadcast`. - self.subscriber.start_announce( - path, - None, - crate::Hops::new(), - crate::origin::Cost::UNKNOWN, - 0, - run.responder_origin, - &mut run.announced, - )?; - } - let PrefixState::ReadInit { stream, run } = std::mem::replace(&mut self.state, PrefixState::Open) - else { - unreachable!() - }; + // Lite05+: reading the publisher's ANNOUNCE_OK. + let ok = wait!(ReadOk => match self.subscriber.version.has_announce_ok() { + true => stream.reader.poll_decode::(waiter).map_ok(Some), + false => Poll::Ready(Ok(None)), + })?; + // The publisher reports its own origin id, which we stamp onto every received + // Announce's hop chain since it no longer does so itself. A peer may legally + // report id 0 (no identity). Keep it: the assigned identity stays on `via` and + // is never forwarded as a hop. Lite05/06 mark the initial set by count, the + // ANNOUNCE_STARTs the publisher counted into it; lite07 waits for SYNCED. + let (responder_origin, initial): (Option, u64) = match ok { + Some(ok) => { + if ok.active == 0 && !version.has_synced() { self.snapshot = None; - self.state = PrefixState::Run { stream, run }; } - PrefixState::Run { stream, run } => { - // A draining peer usually stops announcing, so react to the - // GOAWAY itself; waiting for another message would leave the - // route primary until the session finally closed. Idempotent, - // since the signal stays set. - if self.subscriber.going_away.poll(waiter).is_ready() { - run.announced.drain(); - } - // A new limit holds back what the peer may no longer publish to us, - // and brings back what it may again. The peer still holds each - // advertisement either way. - while let Poll::Ready(permit) = - self.subscriber - .auth - .poll_permit(crate::auth::Direction::Subscribe, &mut run.auth_epoch, waiter) - { - run.announced.limit(&permit, &self.subscriber); - } - loop { - match stream.reader.poll_decode_maybe::(waiter) { - Poll::Ready(Ok(Some(announce))) => { - if matches!(announce, lite::AnnounceBroadcast::Synced) { - if self.snapshot.take().is_none() { - return Poll::Ready(Err(Error::ProtocolViolation)); - } - continue; - } - if run.initial > 0 { - match announce { - lite::AnnounceBroadcast::Active { .. } => run.initial -= 1, - // An unknown type is no change, so it neither counts nor cuts. - lite::AnnounceBroadcast::Skipped => {} - _ => return Poll::Ready(Err(Error::ProtocolViolation)), - } - } - self.subscriber.handle_announce(&self.prefix, announce, run)?; - // Released only once the last counted route is in the origin. - if run.initial == 0 && !self.subscriber.version.has_synced() { - self.snapshot = None; - } - } - Poll::Ready(Ok(None)) if run.initial > 0 || self.snapshot.is_some() => { + (Some(ok.origin), ok.active) + } + None => (None, 0), + }; + + // Waiting for the link cost (may block on the peer's SETUP). + let link_cost = wait!(Cost => self.subscriber.poll_link_cost(waiter)); + let mut run: PrefixRun = PrefixRun { + responder_origin, + link_cost, + announced: Announced::new(self.subscriber.announces.clone()), + decoder: lite::AnnounceDecoder::default(), + auth_epoch: 0, + initial, + }; + + // Lite01/02 send the initial set as one ANNOUNCE_INIT message, so they + // read that before the update stream. Every other version streams it as + // ordinary announces. Each suffix takes an announce slot, so a set past + // what is left of the budget is refused before it is decoded. + let init = wait!(ReadInit => match self.subscriber.version { + Version::Lite01 | Version::Lite02 => { + let budget = run.announced.slots.available(); + stream + .reader + .poll_decode_with(waiter, |r| lite::AnnounceInit::decode_within(r, *version, budget)) + .map_ok(Some) + } + _ => Poll::Ready(Ok(None)), + })?; + if let Some(init) = init { + for suffix in init.suffixes { + let path = self.prefix.join(&suffix)?; + // Lite01/02 don't carry hop information; the broadcast starts with + // an empty chain and an unpriced link. Stats are attributed in the + // model when this enters the origin via `create_broadcast`. + self.subscriber.start_announce( + path, + None, + crate::Hops::new(), + crate::origin::Cost::UNKNOWN, + 0, + run.responder_origin, + &mut run.announced, + )?; + } + self.snapshot = None; + } + + // Streaming announce updates. + Poll::Ready(wait!(Run => { + // A draining peer usually stops announcing, so react to the + // GOAWAY itself; waiting for another message would leave the + // route primary until the session finally closed. Idempotent, + // since the signal stays set. + if self.subscriber.going_away.poll(waiter).is_ready() { + run.announced.drain(); + } + // A new limit holds back what the peer may no longer publish to us, + // and brings back what it may again. The peer still holds each + // advertisement either way. + while let Poll::Ready(permit) = + self.subscriber + .auth + .poll_permit(crate::auth::Direction::Subscribe, &mut run.auth_epoch, waiter) + { + run.announced.limit(&permit, &self.subscriber); + } + loop { + match stream.reader.poll_decode_maybe::(waiter) { + Poll::Ready(Ok(Some(announce))) => { + if matches!(announce, lite::AnnounceBroadcast::Synced) { + if self.snapshot.take().is_none() { return Poll::Ready(Err(Error::ProtocolViolation)); } - Poll::Ready(Ok(None)) => { - // The publisher FINed: it has nothing (more) to announce for this - // prefix (e.g. a publish-only peer). That's a clean completion of - // this announce stream, not a session error, so finish our side - // and return Ok. Tearing down only the announce stream is correct - // since no further progress can be made, but we must not - // propagate an error that would kill the whole connection. - stream.writer.finish().ok(); - return Poll::Ready(Ok(())); + continue; + } + if run.initial > 0 { + match announce { + lite::AnnounceBroadcast::Active { .. } => run.initial -= 1, + // An unknown type is no change, so it neither counts nor cuts. + lite::AnnounceBroadcast::Skipped => {} + _ => return Poll::Ready(Err(Error::ProtocolViolation)), } - Poll::Ready(Err(err)) => return Poll::Ready(Err(err)), - Poll::Pending => break, + } + self.subscriber.handle_announce(&self.prefix, announce, run)?; + // Released only once the last counted route is in the origin. + if run.initial == 0 && !self.subscriber.version.has_synced() { + self.snapshot = None; } } - // Serve the routes whose request queue woke, including any attached - // above. Each route parks on its own waker, so the rest cost nothing. - run.announced.poll_serve(&self.subscriber, waiter); - return Poll::Pending; + Poll::Ready(Ok(None)) if run.initial > 0 || self.snapshot.is_some() => { + return Poll::Ready(Err(Error::ProtocolViolation)); + } + Poll::Ready(Ok(None)) => { + // The publisher FINed: it has nothing (more) to announce for this + // prefix (e.g. a publish-only peer). That's a clean completion of + // this announce stream, not a session error, so finish our side + // and return Ok. Tearing down only the announce stream is correct + // since no further progress can be made, but we must not + // propagate an error that would kill the whole connection. + stream.writer.finish().ok(); + return Poll::Ready(Ok(())); + } + Poll::Ready(Err(err)) => return Poll::Ready(Err(err)), + Poll::Pending => break, } } - } + // Serve the routes whose request queue woke, including any attached + // above. Each route parks on its own waker, so the rest cost nothing. + run.announced.poll_serve(&self.subscriber, waiter); + Poll::Pending + })) } } @@ -6863,7 +6749,7 @@ impl TrackServe { subscription, ranges, tail, - state: EstablishState::Open, + state: EstablishState::Start, } } @@ -6974,80 +6860,56 @@ struct Establish { state: EstablishState, } -enum EstablishState { - Open, - Send { - stream: Stream, - }, - /// Older drafts: the first SUBSCRIBE_OK confirms it. Bail if the session - /// dies meanwhile; a dying route hands the assignment back through the - /// serve loop's teardown instead. - WaitOk { - stream: Stream, - }, -} - +#[kio::machine(self.state: EstablishState)] impl Establish { fn poll(&mut self, waiter: &kio::Waiter) -> Poll> { + #[every_poll] self.validity.check(waiter)?; - loop { - match &mut self.state { - EstablishState::Open => { - let mut stream = ready!(Stream::poll_open_request( - &self.session, - self.serve.subscriber.version, - waiter - ))?; - - let msg = lite::Subscribe { - epoch: self.serve.epoch.clone(), - id: self.id, - broadcast: self.serve.path.clone(), - track: self.serve.name.as_str().into(), - priority: self.subscription.priority, - max_delay: wire_max_delay(self.subscription.max_delay), - ranges: self.ranges.clone(), - order: self.subscription.order, - }; - stream = stream.with_stats(self.serve.subscriber.origin.stats()); - stream.writer.buffer(&lite::ControlType::Subscribe)?; - stream.writer.buffer(&msg)?; - self.state = EstablishState::Send { stream }; - } - EstablishState::Send { stream } => { - ready!(stream.writer.poll_flush(waiter))?; - let EstablishState::Send { stream } = std::mem::replace(&mut self.state, EstablishState::Open) - else { - unreachable!() - }; - if !self.serve.subscriber.version.has_track_stream() { - self.state = EstablishState::WaitOk { stream }; - continue; - } - return Poll::Ready(Ok(self.activate(stream, false))); - } - EstablishState::WaitOk { stream } => { - if let Poll::Ready(err) = self.closed.poll_closed(waiter) { - return Poll::Ready(Err(crate::lite::error::from_transport(err))); - } - let resp = ready!(stream.reader.poll_decode::(waiter))?; - if !matches!(resp, lite::SubscribeResponse::Ok(_)) { - return Poll::Ready(Err(Error::ProtocolViolation)); - } - let EstablishState::WaitOk { stream } = std::mem::replace(&mut self.state, EstablishState::Open) - else { - unreachable!() - }; - return Poll::Ready(Ok(self.activate(stream, true))); - } + + let mut stream: Stream = wait!(Open => Stream::poll_open_request( + &self.session, + self.serve.subscriber.version, + waiter + ))?; + let msg = lite::Subscribe { + epoch: self.serve.epoch.clone(), + id: self.id, + broadcast: self.serve.path.clone(), + track: self.serve.name.as_str().into(), + priority: self.subscription.priority, + max_delay: wire_max_delay(self.subscription.max_delay), + ranges: self.ranges.clone(), + order: self.subscription.order, + }; + stream = stream.with_stats(self.serve.subscriber.origin.stats()); + stream.writer.buffer(&lite::ControlType::Subscribe)?; + stream.writer.buffer(&msg)?; + wait!(Send => stream.writer.poll_flush(waiter))?; + if self.serve.subscriber.version.has_track_stream() { + return Poll::Ready(Ok(self.activate(stream, false))); + } + + // Older drafts: the first SUBSCRIBE_OK confirms it. Bail if the session dies + // meanwhile; a dying route hands the assignment back through the serve loop's + // teardown instead. + let resp = wait!(WaitOk => { + if let Poll::Ready(err) = self.closed.poll_closed(waiter) { + return Poll::Ready(Err(crate::lite::error::from_transport(err))); } + stream.reader.poll_decode::(waiter) + })?; + if !matches!(resp, lite::SubscribeResponse::Ok(_)) { + return Poll::Ready(Err(Error::ProtocolViolation)); } + Poll::Ready(Ok(self.activate(stream, true))) } /// Give up on the SUBSCRIBE, resetting it with `err` if it reached the wire. fn abort(self, err: &Error) { self.serve.subscriber.remove_subscribe(self.id); - if let EstablishState::Send { stream } | EstablishState::WaitOk { stream } = self.state { + if let EstablishState::Send(EstablishStateSend { stream }) + | EstablishState::WaitOk(EstablishStateWaitOk { stream }) = self.state + { stream.writer.abort(err); } } @@ -7291,21 +7153,7 @@ struct TrackInfoFetch { state: TrackInfoState, } -enum TrackInfoState { - Open, - Send { - stream: Stream, - }, - Read { - stream: Stream, - }, - /// Reading the TRACK_PROPERTIES the `ietf` extension sends after TRACK_INFO. - Properties { - stream: Stream, - info: track::Info, - }, -} - +#[kio::machine(self.state: TrackInfoState)] impl TrackInfoFetch { fn new(serve: &TrackServe) -> Self { let session = serve.subscriber.session.clone(); @@ -7313,7 +7161,7 @@ impl TrackInfoFetch { validity: serve.validity.start(), closed: session.clone(), session, - state: TrackInfoState::Open, + state: TrackInfoState::Start, } } @@ -7322,7 +7170,9 @@ impl TrackInfoFetch { serve: &TrackServe, waiter: &kio::Waiter, ) -> Poll> { + #[every_poll] self.validity.check(waiter)?; + #[every_poll] if serve .route .as_ref() @@ -7330,71 +7180,48 @@ impl TrackInfoFetch { { return Poll::Ready(Err(Error::Unroutable)); } - loop { - match &mut self.state { - TrackInfoState::Open => { - let mut stream = ready!(Stream::poll_open_request( - &self.session, - serve.subscriber.version, - waiter - ))?; - stream = stream.with_stats(serve.subscriber.origin.stats()); - stream.writer.buffer(&lite::ControlType::Track)?; - stream.writer.buffer(&lite::Track { - epoch: serve.epoch.clone(), - broadcast: serve.path.clone(), - track: serve.name.as_str().into(), - })?; - self.state = TrackInfoState::Send { stream }; - } - TrackInfoState::Send { stream } => { - ready!(stream.writer.poll_flush(waiter))?; - let TrackInfoState::Send { stream } = std::mem::replace(&mut self.state, TrackInfoState::Open) - else { - unreachable!() - }; - self.state = TrackInfoState::Read { stream }; - } - TrackInfoState::Read { stream } => { - if let Poll::Ready(err) = self.closed.poll_closed(waiter) { - return Poll::Ready(Err(crate::lite::error::from_transport(err))); - } - let ietf = ready!(serve.subscriber.peer_setup.poll_ietf(waiter)); - let info = ready!(stream.reader.poll_decode::(waiter))?; - let TrackInfoState::Read { stream } = std::mem::replace(&mut self.state, TrackInfoState::Open) - else { - unreachable!() - }; - // Publisher Max Age rides on the wire, so the local retention - // window matches what the upstream advertises (relays re-serve with - // the same bound). `broadcast` is left at its default here; - // `track::Request::accept` stamps the track's real broadcast. - let model = track::Info::from(info); - if !ietf { - return Poll::Ready(Ok((model, HeldTrack(stream)))); - } - self.state = TrackInfoState::Properties { stream, info: model }; - } - TrackInfoState::Properties { stream, info } => { - if let Poll::Ready(err) = self.closed.poll_closed(waiter) { - return Poll::Ready(Err(crate::lite::error::from_transport(err))); - } - let properties = ready!(stream.reader.poll_decode::(waiter))?; - // Refused as moq-transport ingress refuses it. - if let Some(err) = properties.0.as_ref().and_then(|properties| properties.refused(info)) { - return Poll::Ready(Err(err)); - } - let TrackInfoState::Properties { stream, mut info } = - std::mem::replace(&mut self.state, TrackInfoState::Open) - else { - unreachable!() - }; - info.properties = properties.0; - return Poll::Ready(Ok((info, HeldTrack(stream)))); - } + let mut stream: Stream = + wait!(Open => Stream::poll_open_request(&self.session, serve.subscriber.version, waiter))? + .with_stats(serve.subscriber.origin.stats()); + stream.writer.buffer(&lite::ControlType::Track)?; + stream.writer.buffer(&lite::Track { + epoch: serve.epoch.clone(), + broadcast: serve.path.clone(), + track: serve.name.as_str().into(), + })?; + wait!(Send => stream.writer.poll_flush(waiter))?; + + let (ietf, info) = wait!(Read => { + if let Poll::Ready(err) = self.closed.poll_closed(waiter) { + return Poll::Ready(Err(crate::lite::error::from_transport(err))); } + let ietf = ready!(serve.subscriber.peer_setup.poll_ietf(waiter)); + stream.reader.poll_decode::(waiter).map_ok(|info| (ietf, info)) + })?; + + // Publisher Max Age rides on the wire, so the local retention + // window matches what the upstream advertises (relays re-serve with + // the same bound). `broadcast` is left at its default here; + // `track::Request::accept` stamps the track's real broadcast. + let mut info: track::Info = track::Info::from(info); + if !ietf { + return Poll::Ready(Ok((info, HeldTrack(stream)))); + } + + // Reading the TRACK_PROPERTIES the `ietf` extension sends after TRACK_INFO. + let properties = wait!(Properties => { + if let Poll::Ready(err) = self.closed.poll_closed(waiter) { + return Poll::Ready(Err(crate::lite::error::from_transport(err))); + } + stream.reader.poll_decode::(waiter) + })?; + // Refused as moq-transport ingress refuses it. + if let Some(err) = properties.0.as_ref().and_then(|properties| properties.refused(&info)) { + return Poll::Ready(Err(err)); } + info.properties = properties.0; + Poll::Ready(Ok((info, HeldTrack(stream)))) } } From 1d977a62799369affabb87578c3482ebce1790cb Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:24:17 -0700 Subject: [PATCH 3/8] feat(kio): machine docs, format captures, and moq-net guidance Co-Authored-By: Claude Opus 5.5 --- doc/setup/upgrade.md | 2 +- rs/AGENTS.md | 1 + rs/kio/README.md | 2 ++ rs/kio/macros/Cargo.toml | 2 ++ rs/kio/macros/MIGRATE.md | 5 ++++ rs/kio/macros/src/lib.rs | 43 ++++++++++++++++++++++++++++------ rs/kio/macros/tests/machine.rs | 30 ++++++++++++++++++++++++ rs/kio/macros/tests/ui.rs | 4 ++++ rs/kio/src/lib.rs | 3 +++ 9 files changed, 84 insertions(+), 8 deletions(-) create mode 100644 rs/kio/macros/MIGRATE.md diff --git a/doc/setup/upgrade.md b/doc/setup/upgrade.md index ee1ecd9583b..835c80318d8 100644 --- a/doc/setup/upgrade.md +++ b/doc/setup/upgrade.md @@ -27,7 +27,7 @@ replaces it. - **Binaries:** [moq-relay](https://github.com/moq-dev/moq/blob/main/rs/moq-relay/MIGRATE.md), [moq-cli (`moq`)](https://github.com/moq-dev/moq/blob/main/rs/moq-cli/MIGRATE.md), [moq-gst](https://github.com/moq-dev/moq/blob/main/rs/moq-gst/MIGRATE.md), [obs-moq](https://github.com/moq-dev/moq/blob/main/cpp/obs/MIGRATE.md) - **Bindings:** [moq-ffi (UniFFI)](https://github.com/moq-dev/moq/blob/main/rs/moq-ffi/MIGRATE.md), [moq-c (C)](https://github.com/moq-dev/moq/blob/main/rs/moq-c/MIGRATE.md), [Python](https://github.com/moq-dev/moq/blob/main/py/moq-rs/MIGRATE.md), [Go](https://github.com/moq-dev/moq/blob/main/go/wrapper/MIGRATE.md), [Swift](https://github.com/moq-dev/moq/blob/main/swift/MIGRATE.md), [Kotlin](https://github.com/moq-dev/moq/blob/main/kt/moq/MIGRATE.md), [Dart](https://github.com/moq-dev/moq/blob/main/dart/moq/MIGRATE.md), [C++](https://github.com/moq-dev/moq/blob/main/cpp/moq/MIGRATE.md) -- **Rust:** [hang](https://github.com/moq-dev/moq/blob/main/rs/hang/MIGRATE.md), [kio](https://github.com/moq-dev/moq/blob/main/rs/kio/MIGRATE.md), [moq-archive](https://github.com/moq-dev/moq/blob/main/rs/moq-archive/MIGRATE.md), [moq-audio](https://github.com/moq-dev/moq/blob/main/rs/moq-audio/MIGRATE.md), [moq-auth](https://github.com/moq-dev/moq/blob/main/rs/moq-auth/MIGRATE.md), [moq-boy](https://github.com/moq-dev/moq/blob/main/rs/moq-boy/MIGRATE.md), [moq-clock](https://github.com/moq-dev/moq/blob/main/rs/moq-clock/MIGRATE.md), [moq-clock-macros](https://github.com/moq-dev/moq/blob/main/rs/moq-clock/macros/MIGRATE.md), [moq-e2ee](https://github.com/moq-dev/moq/blob/main/rs/moq-e2ee/MIGRATE.md), [moq-flate](https://github.com/moq-dev/moq/blob/main/rs/moq-flate/MIGRATE.md), [moq-hls](https://github.com/moq-dev/moq/blob/main/rs/moq-hls/MIGRATE.md), [moq-ice](https://github.com/moq-dev/moq/blob/main/rs/moq-ice/MIGRATE.md), [moq-json](https://github.com/moq-dev/moq/blob/main/rs/moq-json/MIGRATE.md), [moq-loc](https://github.com/moq-dev/moq/blob/main/rs/moq-loc/MIGRATE.md), [moq-msf](https://github.com/moq-dev/moq/blob/main/rs/moq-msf/MIGRATE.md), [moq-mux](https://github.com/moq-dev/moq/blob/main/rs/moq-mux/MIGRATE.md), [moq-net](https://github.com/moq-dev/moq/blob/main/rs/moq-net/MIGRATE.md), [moq-nvenc](https://github.com/moq-dev/moq/blob/main/rs/moq-nvenc/MIGRATE.md), [moq-pattern](https://github.com/moq-dev/moq/blob/main/rs/moq-pattern/MIGRATE.md), [moq-quic](https://github.com/moq-dev/moq/blob/main/rs/moq-quic/MIGRATE.md), [moq-room](https://github.com/moq-dev/moq/blob/main/rs/moq-room/MIGRATE.md), [moq-rtc](https://github.com/moq-dev/moq/blob/main/rs/moq-rtc/MIGRATE.md), [moq-rtmp](https://github.com/moq-dev/moq/blob/main/rs/moq-rtmp/MIGRATE.md), [moq-sock](https://github.com/moq-dev/moq/blob/main/rs/moq-sock/MIGRATE.md), [moq-srt](https://github.com/moq-dev/moq/blob/main/rs/moq-srt/MIGRATE.md), [moq-stats](https://github.com/moq-dev/moq/blob/main/rs/moq-stats/MIGRATE.md), [moq-tokio](https://github.com/moq-dev/moq/blob/main/rs/moq-tokio/MIGRATE.md), [moq-transcode](https://github.com/moq-dev/moq/blob/main/rs/moq-transcode/MIGRATE.md), [moq-uring](https://github.com/moq-dev/moq/blob/main/rs/moq-uring/MIGRATE.md), [moq-v4l](https://github.com/moq-dev/moq/blob/main/rs/moq-v4l/MIGRATE.md), [moq-video](https://github.com/moq-dev/moq/blob/main/rs/moq-video/MIGRATE.md), [qmux](https://github.com/moq-dev/moq/blob/main/rs/qmux/MIGRATE.md) +- **Rust:** [hang](https://github.com/moq-dev/moq/blob/main/rs/hang/MIGRATE.md), [kio](https://github.com/moq-dev/moq/blob/main/rs/kio/MIGRATE.md), [kio-macros](https://github.com/moq-dev/moq/blob/main/rs/kio/macros/MIGRATE.md), [moq-archive](https://github.com/moq-dev/moq/blob/main/rs/moq-archive/MIGRATE.md), [moq-audio](https://github.com/moq-dev/moq/blob/main/rs/moq-audio/MIGRATE.md), [moq-auth](https://github.com/moq-dev/moq/blob/main/rs/moq-auth/MIGRATE.md), [moq-boy](https://github.com/moq-dev/moq/blob/main/rs/moq-boy/MIGRATE.md), [moq-clock](https://github.com/moq-dev/moq/blob/main/rs/moq-clock/MIGRATE.md), [moq-clock-macros](https://github.com/moq-dev/moq/blob/main/rs/moq-clock/macros/MIGRATE.md), [moq-e2ee](https://github.com/moq-dev/moq/blob/main/rs/moq-e2ee/MIGRATE.md), [moq-flate](https://github.com/moq-dev/moq/blob/main/rs/moq-flate/MIGRATE.md), [moq-hls](https://github.com/moq-dev/moq/blob/main/rs/moq-hls/MIGRATE.md), [moq-ice](https://github.com/moq-dev/moq/blob/main/rs/moq-ice/MIGRATE.md), [moq-json](https://github.com/moq-dev/moq/blob/main/rs/moq-json/MIGRATE.md), [moq-loc](https://github.com/moq-dev/moq/blob/main/rs/moq-loc/MIGRATE.md), [moq-msf](https://github.com/moq-dev/moq/blob/main/rs/moq-msf/MIGRATE.md), [moq-mux](https://github.com/moq-dev/moq/blob/main/rs/moq-mux/MIGRATE.md), [moq-net](https://github.com/moq-dev/moq/blob/main/rs/moq-net/MIGRATE.md), [moq-nvenc](https://github.com/moq-dev/moq/blob/main/rs/moq-nvenc/MIGRATE.md), [moq-pattern](https://github.com/moq-dev/moq/blob/main/rs/moq-pattern/MIGRATE.md), [moq-quic](https://github.com/moq-dev/moq/blob/main/rs/moq-quic/MIGRATE.md), [moq-room](https://github.com/moq-dev/moq/blob/main/rs/moq-room/MIGRATE.md), [moq-rtc](https://github.com/moq-dev/moq/blob/main/rs/moq-rtc/MIGRATE.md), [moq-rtmp](https://github.com/moq-dev/moq/blob/main/rs/moq-rtmp/MIGRATE.md), [moq-sock](https://github.com/moq-dev/moq/blob/main/rs/moq-sock/MIGRATE.md), [moq-srt](https://github.com/moq-dev/moq/blob/main/rs/moq-srt/MIGRATE.md), [moq-stats](https://github.com/moq-dev/moq/blob/main/rs/moq-stats/MIGRATE.md), [moq-tokio](https://github.com/moq-dev/moq/blob/main/rs/moq-tokio/MIGRATE.md), [moq-transcode](https://github.com/moq-dev/moq/blob/main/rs/moq-transcode/MIGRATE.md), [moq-uring](https://github.com/moq-dev/moq/blob/main/rs/moq-uring/MIGRATE.md), [moq-v4l](https://github.com/moq-dev/moq/blob/main/rs/moq-v4l/MIGRATE.md), [moq-video](https://github.com/moq-dev/moq/blob/main/rs/moq-video/MIGRATE.md), [qmux](https://github.com/moq-dev/moq/blob/main/rs/qmux/MIGRATE.md) - **JavaScript:** [`@moq/auth`](https://github.com/moq-dev/moq/blob/main/js/auth/MIGRATE.md), [`@moq/boy`](https://github.com/moq-dev/moq/blob/main/js/moq-boy/MIGRATE.md), [`@moq/clock`](https://github.com/moq-dev/moq/blob/main/js/clock/MIGRATE.md), [`@moq/flate`](https://github.com/moq-dev/moq/blob/main/js/flate/MIGRATE.md), [`@moq/hang`](https://github.com/moq-dev/moq/blob/main/js/hang/MIGRATE.md), [`@moq/json`](https://github.com/moq-dev/moq/blob/main/js/json/MIGRATE.md), [`@moq/loc`](https://github.com/moq-dev/moq/blob/main/js/loc/MIGRATE.md), [`@moq/msf`](https://github.com/moq-dev/moq/blob/main/js/msf/MIGRATE.md), [`@moq/net`](https://github.com/moq-dev/moq/blob/main/js/net/MIGRATE.md), [`@moq/p2p`](https://github.com/moq-dev/moq/blob/main/js/p2p/MIGRATE.md), [`@moq/pattern`](https://github.com/moq-dev/moq/blob/main/js/pattern/MIGRATE.md), [`@moq/publish`](https://github.com/moq-dev/moq/blob/main/js/publish/MIGRATE.md), [`@moq/qmux`](https://github.com/moq-dev/moq/blob/main/js/qmux/MIGRATE.md), [`@moq/room`](https://github.com/moq-dev/moq/blob/main/js/room/MIGRATE.md), [`@moq/signals`](https://github.com/moq-dev/moq/blob/main/js/signals/MIGRATE.md), [`@moq/ui`](https://github.com/moq-dev/moq/blob/main/js/ui/MIGRATE.md), [`@moq/video`](https://github.com/moq-dev/moq/blob/main/js/video/MIGRATE.md), [`@moq/watch`](https://github.com/moq-dev/moq/blob/main/js/watch/MIGRATE.md) ## Unreleased diff --git a/rs/AGENTS.md b/rs/AGENTS.md index b0ee466bad2..f2f4b59b64c 100644 --- a/rs/AGENTS.md +++ b/rs/AGENTS.md @@ -24,6 +24,7 @@ Two ways to drive things, both backed by `kio`: Prefer poll. New logic is a `poll_*` with an `async` helper, not the other way around. `pin!` then polling inside `kio::wait` is a code smell, as is `tokio::spawn` / `select!` inside a library; use `kio` primitives. Don't color APIs with `Send` bounds that native needs and wasm can't satisfy. +- A `poll_*` that waits on several things in a fixed order is a `#[kio::machine]` (kio's `macros` feature): straight-line code with a `wait!` at each wait, from which it writes the state enum and its transitions. Hand-write the machine when a wait sits in a loop or branch, or when it yields more than once (a stream's `poll_next`). A conditional wait is one whose poll is ready at once. - Use `ready!(...)` instead of `Poll::Pending => return Poll::Pending`. - `Poll>` supports `?`: `ready!(poll())?` or `match poll()?`. - Prefer `Ok(x?)` over `.map_err(Into::into)`. diff --git a/rs/kio/README.md b/rs/kio/README.md index 5118e15effc..cbd1dbf2e13 100644 --- a/rs/kio/README.md +++ b/rs/kio/README.md @@ -22,6 +22,8 @@ waiter-based polls when implementing `Future` or `poll_*` on top of kio channels work ready still yields to the rest of its runtime. `log::Writer` is an append-only log whose `log::Reader`s read committed entries by index without a lock, paired with a channel that parks them; evicted entries are freed by epoch-based reclamation. +With the `macros` feature, `#[kio::machine]` writes a `poll_*` state machine from +straight-line code with explicit waits. It's used internally by [moq-net](https://github.com/moq-dev/moq/tree/main/rs/moq-net) and friends, but is generic enough to be useful on its own. diff --git a/rs/kio/macros/Cargo.toml b/rs/kio/macros/Cargo.toml index 4d3ae94692f..fa1c926d4d5 100644 --- a/rs/kio/macros/Cargo.toml +++ b/rs/kio/macros/Cargo.toml @@ -26,6 +26,8 @@ syn = { version = "2", features = ["full", "visit-mut"] } [dev-dependencies] kio = { path = "..", features = ["macros"] } +# Runs the UI cases outside clippy, which would print their types with full paths. +test-env = { path = "../../test-env" } # Compiles each mistake in `tests/ui/` and checks the diagnostic it reports. trybuild = "1" diff --git a/rs/kio/macros/MIGRATE.md b/rs/kio/macros/MIGRATE.md new file mode 100644 index 00000000000..1bbdb6962d7 --- /dev/null +++ b/rs/kio/macros/MIGRATE.md @@ -0,0 +1,5 @@ +# Migrating kio-macros + +How to update your code for each breaking change, newest first. + +## Unreleased diff --git a/rs/kio/macros/src/lib.rs b/rs/kio/macros/src/lib.rs index 8e83fc36981..8aa73aec30c 100644 --- a/rs/kio/macros/src/lib.rs +++ b/rs/kio/macros/src/lib.rs @@ -19,9 +19,10 @@ use syn::{ /// /// `#[kio::machine(self.state: Name)]` on an `impl` generates `enum Name` and rewrites /// the one method that uses `wait!` to resume from `self.state`. The struct declares -/// `state: Name` and starts it at `Name::Start`. Each wait gets a variant holding the -/// struct of the locals that live across it, `Name`, and the machine is -/// `Name::Done` once it returns `Poll::Ready`. `Name::name()` says where it waits. +/// `state: Name` and starts it at `Name::Start`. Each wait gets a variant holding a +/// struct of the locals that live across it, `Name::Step(NameStep { .. })`, and the +/// machine is `Name::Done` once it returns `Poll::Ready`. `Name::name()` says where it +/// waits. /// /// ``` /// use std::task::Poll; @@ -63,6 +64,9 @@ use syn::{ /// - A local used after a wait must be bound as `let name: Type`, since its type /// becomes a field. It is dropped when the machine leaves the last wait it lives /// across, as a hand-written machine would. +/// - Which locals a wait stores is found by name, format string captures included. A +/// later binding that reuses a moved local's name, as a closure argument or an inner +/// `let`, still stores it and fails as a use after move: rename one of them. /// - The body ends in its `Poll::Ready` value. Polling a `Done` machine panics. /// - `Name` is `Send` when every stored local is. A `!Send` local reports its `let` /// and its wait. @@ -739,28 +743,53 @@ fn uses(tokens: TokenStream) -> HashSet { fn walk(tokens: TokenStream, in_macro: bool, into: &mut HashSet) { let punct = |token: &Option, c: char| matches!(token, Some(TokenTree::Punct(p)) if p.as_char() == c); let (mut prev, mut prev2) = (None, None); + // A format string's captures, less the named arguments that answer them. + let (mut captured, mut named) = (HashSet::new(), HashSet::new()); let mut tokens = tokens.into_iter().peekable(); while let Some(token) = tokens.next() { let tail = punct(&prev, '.') || (punct(&prev, ':') && punct(&prev2, ':')); match &token { TokenTree::Ident(ident) if !tail => { - let named = in_macro + let argument = in_macro && matches!(tokens.peek(), Some(TokenTree::Punct(eq)) if eq.as_char() == '=' && eq.spacing() == Spacing::Alone); - if !named { - into.insert(ident.to_string()); - } + match argument { + true => named.insert(ident.to_string()), + false => into.insert(ident.to_string()), + }; } TokenTree::Group(group) => walk(group.stream(), in_macro || punct(&prev, '!'), into), + TokenTree::Literal(literal) if in_macro => captures(&literal.to_string(), &mut captured), _ => {} } prev2 = prev.replace(token); } + into.extend(captured.into_iter().filter(|name| !named.contains(name))); } let mut into = HashSet::new(); walk(tokens, false, &mut into); into } +/// The locals a format string captures, as `x` in `"{x}"` or `"{x:?}"`. Any other +/// literal holds no `{`, or no identifier after one. +fn captures(literal: &str, into: &mut HashSet) { + let mut rest = literal; + while let Some(at) = rest.find('{') { + rest = &rest[at + 1..]; + if let Some(escaped) = rest.strip_prefix('{') { + rest = escaped; + continue; + } + let end = rest + .find(|c: char| !(c.is_alphanumeric() || c == '_')) + .unwrap_or(rest.len()); + let name = &rest[..end]; + if name.starts_with(|c: char| c.is_alphabetic() || c == '_') { + into.insert(name.to_string()); + } + } +} + /// What a statement reads, and what it binds if it is a `let`. struct Reads { uses: HashSet, diff --git a/rs/kio/macros/tests/machine.rs b/rs/kio/macros/tests/machine.rs index 4fe1113699c..b0d342e0795 100644 --- a/rs/kio/macros/tests/machine.rs +++ b/rs/kio/macros/tests/machine.rs @@ -192,3 +192,33 @@ fn skips_a_conditional_wait() { values.try_push(3).unwrap(); assert_eq!(maybe.poll_maybe(&waiter), Poll::Ready(Ok(5))); } + +/// A typed tuple binding, and a macro's named argument that shares a moved local's name. +struct Pair { + values: kio::Queue, + state: PairState, +} + +#[kio::machine(self.state: PairState)] +impl Pair { + fn poll_pair(&mut self, waiter: &kio::Waiter) -> Poll> { + let (low, high): (u64, u64) = wait!(First => self.values.poll_pop(waiter)).map(|first| (first, first + 1))?; + let label: String = format!("{low}"); + // Moved before the wait, so only the named argument below says `label`. + let moved: String = label; + wait!(Second => self.values.poll_pop(waiter))?; + Poll::Ready(Ok(format!("{moved}-{high}-{label}", label = low))) + } +} + +#[test] +fn stores_typed_tuples() { + let values = kio::Queue::new(); + let mut pair = Pair { + values: values.clone(), + state: PairState::Start, + }; + values.try_push(1).unwrap(); + values.try_push(0).unwrap(); + assert_eq!(pair.poll_pair(&kio::Waiter::noop()), Poll::Ready(Ok("1-2-1".to_string()))); +} diff --git a/rs/kio/macros/tests/ui.rs b/rs/kio/macros/tests/ui.rs index 2d6be9cf1f1..e68c5158d0a 100644 --- a/rs/kio/macros/tests/ui.rs +++ b/rs/kio/macros/tests/ui.rs @@ -2,5 +2,9 @@ #[test] fn ui() { + // `just rs test` builds through clippy, which prints types with their full paths. + if !test_env::Env::without(&["RUSTC_WORKSPACE_WRAPPER"]).isolate() { + return; + } trybuild::TestCases::new().compile_fail("tests/ui/*.rs"); } diff --git a/rs/kio/src/lib.rs b/rs/kio/src/lib.rs index 6679fc56128..1a37009095b 100644 --- a/rs/kio/src/lib.rs +++ b/rs/kio/src/lib.rs @@ -20,6 +20,9 @@ //! //! [`coop`] bounds the passes a loop makes per poll, so one that always finds //! work ready still yields. +//! +//! With the `macros` feature, `#[kio::machine]` writes a `poll_*` state machine from +//! straight-line code with explicit waits. #![warn(missing_docs)] From be44abd1bc5bbfe10a4c5a6f6be6f95b354b5dc4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:25:30 -0700 Subject: [PATCH 4/8] docs(kio): machine poll borrows and Send safety note Co-Authored-By: Claude Opus 5.5 --- rs/kio/macros/src/lib.rs | 13 +++++++------ rs/kio/macros/tests/machine.rs | 5 ++++- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/rs/kio/macros/src/lib.rs b/rs/kio/macros/src/lib.rs index 8aa73aec30c..0bc33b69db6 100644 --- a/rs/kio/macros/src/lib.rs +++ b/rs/kio/macros/src/lib.rs @@ -56,8 +56,9 @@ use syn::{ /// - `wait!(Step => poll)` starts a top-level statement, as in `let x: T = wait!(Step => /// poll)?;`. It evaluates `poll`, any `Poll<_>` expression, on every call until it is /// ready, then continues with its value. Inside `poll`, earlier locals are `&mut` -/// borrows of the stored state, so moving one (`drop(x)`) is an error, and a `return` -/// or `ready!` leaves the machine at the wait. +/// borrows of the stored state, so moving one (`drop(x)`) is an error, and the poll +/// can reach `self`'s other fields but not its `&mut self` methods. A `return` or +/// `ready!` inside it leaves the machine at the wait. /// - `#[every_poll]` statements lead the body and run on every call, before resuming. /// - Every other statement runs once, so it must not return `Poll::Pending` or use /// `ready!`. @@ -203,8 +204,11 @@ fn storage(variant: &Variant) -> TokenStream { } // The auto impl, written out so that a `!Send` local reports its own `let` (the - // bound) and its wait (the impl) instead of only the enum. The bound is + // bound) and its wait (the impl) instead of only the enum. Each bound is // higher-ranked so rustc checks it where `Send` is needed, not here. + // + // SAFETY: the bounds are the auto impl's own conditions, every field's type being + // `Send`, and the struct has no fields but these. let bounds = variant.stored.iter().map(|local| { let ty = &local.ty; let send = quote_spanned!(local.ident.span()=> ::core::marker::Send); @@ -213,9 +217,6 @@ fn storage(variant: &Variant) -> TokenStream { let header = quote_spanned!(variant.name.span()=> unsafe impl ::core::marker::Send for #name); quote! { #def - - // SAFETY: these are the auto impl's own conditions, every field's type being - // `Send`; the fields above are all there is. #header where #(#bounds),* {} } } diff --git a/rs/kio/macros/tests/machine.rs b/rs/kio/macros/tests/machine.rs index b0d342e0795..c0fca3db94f 100644 --- a/rs/kio/macros/tests/machine.rs +++ b/rs/kio/macros/tests/machine.rs @@ -220,5 +220,8 @@ fn stores_typed_tuples() { }; values.try_push(1).unwrap(); values.try_push(0).unwrap(); - assert_eq!(pair.poll_pair(&kio::Waiter::noop()), Poll::Ready(Ok("1-2-1".to_string()))); + assert_eq!( + pair.poll_pair(&kio::Waiter::noop()), + Poll::Ready(Ok("1-2-1".to_string())) + ); } From 196940a8d1ed879f6c4ea341388405b17306724b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:25:40 -0700 Subject: [PATCH 5/8] chore: lock test-env for kio-macros Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 1 + 1 file changed, 1 insertion(+) diff --git a/Cargo.lock b/Cargo.lock index fc92b994101..0f00e4db6df 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4615,6 +4615,7 @@ dependencies = [ "proc-macro2", "quote", "syn 2.0.119", + "test-env", "trybuild", ] From 2b9bd139422388d3eb3f72909c07b54c209d1995 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:26:22 -0700 Subject: [PATCH 6/8] quest: finish kio::machine Co-Authored-By: Claude Opus 5.5 --- quest/m1/poll-first/README.md | 1 - quest/m1/poll-first/machine-bodies.md | 15 +++++---- quest/m1/poll-first/machine.md | 46 --------------------------- 3 files changed, 8 insertions(+), 54 deletions(-) delete mode 100644 quest/m1/poll-first/machine.md diff --git a/quest/m1/poll-first/README.md b/quest/m1/poll-first/README.md index ccf5e68d408..4275d596045 100644 --- a/quest/m1/poll-first/README.md +++ b/quest/m1/poll-first/README.md @@ -73,7 +73,6 @@ and their alternatives: ## Required -- [kio::machine](/quest/m1/poll-first/machine.md) - kio's `macros` feature writes straight-line `poll_*` bodies, landing with the hand-written machines it replaces - [Straight-line bodies become machines](/quest/m1/poll-first/machine-bodies.md) - moq-net's straight-line `async fn` bodies become `#[kio::machine]` polls - [Generated async wrappers behind a feature](/quest/m1/poll-first/async-feature.md) - each library's `async fn` wrappers are generated from its `poll_*` signatures and compile only with its `async` feature - [Libraries spawn nothing](/quest/m1/poll-first/no-spawn.md) - web-async goes, and moq-ffi, moq-stats, moq-wasm and moq-relay's cluster and auth run as polled `kio::Tasks` children instead of spawned tasks diff --git a/quest/m1/poll-first/machine-bodies.md b/quest/m1/poll-first/machine-bodies.md index 4af1eea1988..9fa61fb6ee6 100644 --- a/quest/m1/poll-first/machine-bodies.md +++ b/quest/m1/poll-first/machine-bodies.md @@ -10,9 +10,10 @@ generate wrappers for them. Behavior and public signatures are unchanged. ## Plan -Decided with the maintainer on 2026-10-28: split from -[kio::machine](/quest/m1/poll-first/machine.md) so the macro lands with its -hand-written machines first, and these conversions follow as their own PR. +Decided with the maintainer on 2026-10-28: split from the kio::machine quest, +which landed the macro with its hand-written machines in +[moq-dev/moq#7148](https://github.com/moq-dev/moq/pull/7148), so these +conversions follow as their own PR. Bodies with a loop or a branch around a wait stay with async-feature, which converts them by hand. @@ -21,9 +22,9 @@ converts them by hand. - The existing tests are the proof; add one only where a conversion changes cancellation (a value that used to drop at an `.await` now lives in a named variant). +- The macro has only the `impl` form: an `async fn`'s parameters become the + struct's fields. A conditional wait is one whose poll is ready at once, and a + wait that ends the body is `Poll::Ready(wait!(..))`; see `kio::machine`'s docs + for the rest of the dialect. Public API: none. Wire: none. - -## Required - -- [kio::machine](/quest/m1/poll-first/machine.md) - the macro these conversions use diff --git a/quest/m1/poll-first/machine.md b/quest/m1/poll-first/machine.md deleted file mode 100644 index b8d739e2a21..00000000000 --- a/quest/m1/poll-first/machine.md +++ /dev/null @@ -1,46 +0,0 @@ -# [M] kio::machine writes straight-line poll bodies - -## Goal - -kio ships `#[kio::machine]` behind its `macros` feature: a `poll_*` body -written as straight-line code with explicit wait points compiles to a named -state enum and a resumable `poll`. It lands in the same PR as its first -users, the straight-line hand-written state machines in `rs/` (about 12, -including `TrackInfoFetch` in `rs/moq-net/src/lite/subscriber.rs`). Loops -and branches that contain a wait stay out of scope. - -## Plan - -Decided with the maintainer on 2026-10-28, from the -[poll-macro spike](https://github.com/moq-dev/moq/pull/7057): adopt the macro -for straight-line code only, landing with its first users, and add loop -support only once conversions show it is needed. - -- **Start from the prototype** in - [moq-dev/moq@d2fc504](https://github.com/moq-dev/moq/commit/d2fc50458c04d6ab73c2ae4055244b87cdbc111e) - and [moq-dev/moq@f28d5c6](https://github.com/moq-dev/moq/commit/f28d5c618d82872cd77e8b7a30a182fffa0ed215): - `#[kio::machine(self.state: Name)]` on an `impl` block, `wait!(Step => - poll_expr)` at each wait, `#[every_poll]` guards. Keep kio's rules: no - `Pin`, named state, `Send` from named field types. -- **Shipping:** `kio-macros` (syn 2, already in the graph) behind kio's - optional `macros` feature; crates that use it, starting with moq-net, - enable it, so library-only builds that don't use it pay nothing (decided - 2026-10-28). -- **Errors the landed macro must fix** (decided 2026-10-28): - - Inside a wait's poll expression, earlier locals are `&mut` borrows, so - `drop(label)` compiles and silently does nothing. Make that impossible or - a compile error. - - A `!Send` local must name the wait and the local that caused it, for - example with one struct per variant. - - Not required: keeping a borrow of `self` across a wait gives a misleading - "missing lifetime" error. Document it as a known limit. -- **Tests:** trybuild UI tests for each error case in the spike's table, and - the converted machines' existing tests unchanged. -- **Conversions:** every straight-line hand-written state machine in `rs/`; - list each one, and any left by hand with the reason, in the PR. The - straight-line `async fn` bodies are - [their own quest](/quest/m1/poll-first/machine-bodies.md). -- **Docs:** update `rs/AGENTS.md`'s `poll_*` guidance to say when to reach for - the macro. - -Public API: kio gains the `macros` feature and `#[kio::machine]`. Wire: none. From e13230ebe886c0687e4d98fd02403b7b9a6cb621 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 19:19:09 -0700 Subject: [PATCH 7/8] fix(kio): machine state keeps Rust's automatic Send Drop the generated `unsafe impl Send` for each wait's storage struct. A !Send local now reports its type and its wait, not the local. The per-wait structs stay: a struct variant would lose the wait from the error. Co-Authored-By: Claude Opus 5.5 --- quest/m1/poll-first/README.md | 5 ++-- rs/kio/macros/src/lib.rs | 31 ++++----------------- rs/kio/macros/tests/ui/hidden_borrow.stderr | 11 -------- rs/kio/macros/tests/ui/not_send.stderr | 6 ++-- 4 files changed, 11 insertions(+), 42 deletions(-) diff --git a/quest/m1/poll-first/README.md b/quest/m1/poll-first/README.md index 4275d596045..8d44f45d596 100644 --- a/quest/m1/poll-first/README.md +++ b/quest/m1/poll-first/README.md @@ -67,8 +67,9 @@ and their alternatives: type-check and borrow-check cost matches hand-written code; it adds about 1.5 ms of expansion per machine plus a one-time 1.3 s build of `kio-macros`, below what async costs. The cost is a dialect: stored locals need type annotations and are - `&mut` inside a wait's poll, and a `!Send` error doesn't name the wait. Its users - are moq-net's 23 straight-line multi-await `async fn` bodies and 12 straight-line + `&mut` inside a wait's poll, and a `!Send` error names the type and the wait but + not the local: the generated state keeps Rust's automatic `Send`, with no + `unsafe impl` (decided 2026-10-28). Its users are moq-net's 23 straight-line multi-await `async fn` bodies and 12 straight-line hand-written machines; 59 bodies await in loops or selects. ## Required diff --git a/rs/kio/macros/src/lib.rs b/rs/kio/macros/src/lib.rs index 0bc33b69db6..c11b83c846c 100644 --- a/rs/kio/macros/src/lib.rs +++ b/rs/kio/macros/src/lib.rs @@ -6,7 +6,7 @@ use std::collections::HashSet; use proc_macro2::{Spacing, Span, TokenStream, TokenTree}; -use quote::{ToTokens, format_ident, quote, quote_spanned}; +use quote::{ToTokens, format_ident, quote}; use syn::{ Expr, Ident, ImplItem, ItemImpl, Macro, Pat, Stmt, Token, Type, parse::{Parse, ParseStream}, @@ -69,8 +69,8 @@ use syn::{ /// later binding that reuses a moved local's name, as a closure argument or an inner /// `let`, still stores it and fails as a use after move: rename one of them. /// - The body ends in its `Poll::Ready` value. Polling a `Done` machine panics. -/// - `Name` is `Send` when every stored local is. A `!Send` local reports its `let` -/// and its wait. +/// - `Name` is `Send` when every stored local is, by Rust's own auto impl. A `!Send` +/// local reports its type and its wait (`NameStep`), not the local itself. /// /// Not supported: /// @@ -186,7 +186,8 @@ fn expand(args: Args, mut item: ItemImpl) -> syn::Result { }) } -/// One variant's struct of the locals that live across its wait, with their `Send`. +/// One variant's struct of the locals that live across its wait. A struct of its own, +/// rather than a struct variant, so that a `!Send` error names the wait. fn storage(variant: &Variant) -> TokenStream { let name = &variant.storage; let doc = format!("The locals stored across `wait!({} => ..)`.", variant.name); @@ -195,29 +196,9 @@ fn storage(variant: &Variant) -> TokenStream { let ty = &local.ty; quote! { #ident: #ty } }); - let def = quote! { + quote! { #[doc = #doc] struct #name { #(#fields),* } - }; - if variant.stored.is_empty() { - return def; - } - - // The auto impl, written out so that a `!Send` local reports its own `let` (the - // bound) and its wait (the impl) instead of only the enum. Each bound is - // higher-ranked so rustc checks it where `Send` is needed, not here. - // - // SAFETY: the bounds are the auto impl's own conditions, every field's type being - // `Send`, and the struct has no fields but these. - let bounds = variant.stored.iter().map(|local| { - let ty = &local.ty; - let send = quote_spanned!(local.ident.span()=> ::core::marker::Send); - quote! { for<'__kio> #ty: #send } - }); - let header = quote_spanned!(variant.name.span()=> unsafe impl ::core::marker::Send for #name); - quote! { - #def - #header where #(#bounds),* {} } } diff --git a/rs/kio/macros/tests/ui/hidden_borrow.stderr b/rs/kio/macros/tests/ui/hidden_borrow.stderr index 9bb3e9c42ac..4c34b26bff0 100644 --- a/rs/kio/macros/tests/ui/hidden_borrow.stderr +++ b/rs/kio/macros/tests/ui/hidden_borrow.stderr @@ -9,14 +9,3 @@ help: consider introducing a named lifetime parameter 17 ~ let label: std::cell::Ref<'a, u64> = self.cell.borrow(); 18 ~ let b: u64 = wait!(B<'a> => self.values.poll_pop(waiter))?; | - -error[E0106]: missing lifetime specifier - --> ${workspace}/rs/kio/macros/tests/ui/hidden_borrow.rs:17:28 - | -17 | let label: std::cell::Ref = self.cell.borrow(); - | ^ expected named lifetime parameter - | -help: consider using the `'__kio` lifetime - | -17 | let label: std::cell::Ref<'__kio, u64> = self.cell.borrow(); - | +++++++ diff --git a/rs/kio/macros/tests/ui/not_send.stderr b/rs/kio/macros/tests/ui/not_send.stderr index d077a022a2b..1d66c834f4b 100644 --- a/rs/kio/macros/tests/ui/not_send.stderr +++ b/rs/kio/macros/tests/ui/not_send.stderr @@ -4,12 +4,10 @@ error[E0277]: `Rc` cannot be sent between threads safely 26 | assert_send::(); | ^ `Rc` cannot be sent between threads safely | - = help: the trait `Send` is not implemented for `Rc` -note: required for `MStateB` to implement `Send` + = help: within `M`, the trait `Send` is not implemented for `Rc` +note: required because it appears within the type `MStateB` --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:18:22 | -17 | let label: std::rc::Rc = std::rc::Rc::new(format!("m-{a}")); - | ----- unsatisfied trait bound introduced here 18 | let b: u64 = wait!(B => self.values.poll_pop(waiter))?; | ^ note: required because it appears within the type `MState` From 4774d7b2b710a0c856acb20f11660a7d93cea86b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 29 Oct 2026 10:29:43 -0700 Subject: [PATCH 8/8] fix(kio): stabilize machine macro gate checks Keep trybuild diagnostics independent of compiler wrappers and mbx environment restoration. Refresh the macro dependency filter and subscriber mutation after the machine conversion. Co-Authored-By: GPT-6.1 Sol --- .github/workflows/release-gate.yml | 1 + rs/kio/macros/tests/ui.rs | 8 ++++-- rs/kio/macros/tests/ui/branch_wait.stderr | 2 +- .../macros/tests/ui/break_outside_loop.stderr | 2 +- rs/kio/macros/tests/ui/duplicate_wait.stderr | 4 +-- rs/kio/macros/tests/ui/every_poll_late.stderr | 2 +- rs/kio/macros/tests/ui/generic.stderr | 2 +- rs/kio/macros/tests/ui/hidden_borrow.stderr | 2 +- rs/kio/macros/tests/ui/hidden_yield.stderr | 2 +- rs/kio/macros/tests/ui/missing_try.stderr | 2 +- rs/kio/macros/tests/ui/not_send.stderr | 10 ++++---- rs/kio/macros/tests/ui/poll_moves.stderr | 4 +-- rs/kio/macros/tests/ui/poll_type.stderr | 24 +++++++++--------- rs/kio/macros/tests/ui/segment_type.stderr | 2 +- rs/kio/macros/tests/ui/self_borrow.stderr | 2 +- rs/kio/macros/tests/ui/untyped.stderr | 2 +- .../macros/tests/ui/wrong_annotation.stderr | 4 +-- .../subscriber-leaks-broadcasts.patch | 25 ++++++++++--------- 18 files changed, 53 insertions(+), 47 deletions(-) diff --git a/.github/workflows/release-gate.yml b/.github/workflows/release-gate.yml index ad27d8f8c53..ea63f213cad 100644 --- a/.github/workflows/release-gate.yml +++ b/.github/workflows/release-gate.yml @@ -236,6 +236,7 @@ jobs: # Exactly the workspace crates run.sh builds; sh/gh/ts-paths.py fails Check on drift. - "rs/hang/**" - "rs/kio/**" + - "rs/kio/macros/**" - "rs/moq-archive/**" - "rs/moq-auth/**" - "rs/moq-cli/**" diff --git a/rs/kio/macros/tests/ui.rs b/rs/kio/macros/tests/ui.rs index e68c5158d0a..8d557f08bb6 100644 --- a/rs/kio/macros/tests/ui.rs +++ b/rs/kio/macros/tests/ui.rs @@ -2,8 +2,12 @@ #[test] fn ui() { - // `just rs test` builds through clippy, which prints types with their full paths. - if !test_env::Env::without(&["RUSTC_WORKSPACE_WRAPPER"]).isolate() { + // Compiler wrappers change diagnostic types and paths. Prevent nested Cargo + // from restoring mbx's saved environment and reintroducing those wrappers. + if !test_env::Env::without(&["RUSTC_WORKSPACE_WRAPPER", "RUSTC_WRAPPER", "MBX_SESSION_RESTORE"]) + .set("MBX_DISABLE", "1") + .isolate() + { return; } trybuild::TestCases::new().compile_fail("tests/ui/*.rs"); diff --git a/rs/kio/macros/tests/ui/branch_wait.stderr b/rs/kio/macros/tests/ui/branch_wait.stderr index cdcacdcc515..4263d35b9f9 100644 --- a/rs/kio/macros/tests/ui/branch_wait.stderr +++ b/rs/kio/macros/tests/ui/branch_wait.stderr @@ -1,5 +1,5 @@ error: `wait!` must start a top-level statement, outside any branch or loop: `let x: T = wait!(Step => poll)?;` - --> ${workspace}/rs/kio/macros/tests/ui/branch_wait.rs:18:27 + --> tests/ui/branch_wait.rs:18:27 | 18 | let b: u64 = if a > 1 { wait!(B => self.values.poll_pop(waiter))? } else { 0 }; | ^^^^ diff --git a/rs/kio/macros/tests/ui/break_outside_loop.stderr b/rs/kio/macros/tests/ui/break_outside_loop.stderr index 8e61e132043..1166476ac98 100644 --- a/rs/kio/macros/tests/ui/break_outside_loop.stderr +++ b/rs/kio/macros/tests/ui/break_outside_loop.stderr @@ -1,5 +1,5 @@ error: `break` and `continue` need a loop of their own - --> ${workspace}/rs/kio/macros/tests/ui/break_outside_loop.rs:19:4 + --> tests/ui/break_outside_loop.rs:19:4 | 19 | break; | ^^^^^ diff --git a/rs/kio/macros/tests/ui/duplicate_wait.stderr b/rs/kio/macros/tests/ui/duplicate_wait.stderr index 6208376e25f..862392ffae8 100644 --- a/rs/kio/macros/tests/ui/duplicate_wait.stderr +++ b/rs/kio/macros/tests/ui/duplicate_wait.stderr @@ -1,11 +1,11 @@ error: a second `wait!(A => ..)` - --> ${workspace}/rs/kio/macros/tests/ui/duplicate_wait.rs:18:22 + --> tests/ui/duplicate_wait.rs:18:22 | 18 | let b: u64 = wait!(A => self.values.poll_pop(waiter))?; | ^ error: the first is here - --> ${workspace}/rs/kio/macros/tests/ui/duplicate_wait.rs:16:22 + --> tests/ui/duplicate_wait.rs:16:22 | 16 | let a: u64 = wait!(A => self.values.poll_pop(waiter))?; | ^ diff --git a/rs/kio/macros/tests/ui/every_poll_late.stderr b/rs/kio/macros/tests/ui/every_poll_late.stderr index 3e0429463a4..1507c46d55e 100644 --- a/rs/kio/macros/tests/ui/every_poll_late.stderr +++ b/rs/kio/macros/tests/ui/every_poll_late.stderr @@ -1,5 +1,5 @@ error: `#[every_poll]` statements lead the body - --> ${workspace}/rs/kio/macros/tests/ui/every_poll_late.rs:19:3 + --> tests/ui/every_poll_late.rs:19:3 | 19 | let now = 1; | ^^^^^^^^^^^^ diff --git a/rs/kio/macros/tests/ui/generic.stderr b/rs/kio/macros/tests/ui/generic.stderr index 93f5cb3ef26..4c0363c1beb 100644 --- a/rs/kio/macros/tests/ui/generic.stderr +++ b/rs/kio/macros/tests/ui/generic.stderr @@ -1,5 +1,5 @@ error: #[kio::machine] does not support generic impls - --> ${workspace}/rs/kio/macros/tests/ui/generic.rs:11:5 + --> tests/ui/generic.rs:11:5 | 11 | impl M { | ^^^ diff --git a/rs/kio/macros/tests/ui/hidden_borrow.stderr b/rs/kio/macros/tests/ui/hidden_borrow.stderr index 4c34b26bff0..5ea025436d6 100644 --- a/rs/kio/macros/tests/ui/hidden_borrow.stderr +++ b/rs/kio/macros/tests/ui/hidden_borrow.stderr @@ -1,5 +1,5 @@ error[E0106]: missing lifetime specifier - --> ${workspace}/rs/kio/macros/tests/ui/hidden_borrow.rs:17:28 + --> tests/ui/hidden_borrow.rs:17:28 | 17 | let label: std::cell::Ref = self.cell.borrow(); | ^ expected named lifetime parameter diff --git a/rs/kio/macros/tests/ui/hidden_yield.stderr b/rs/kio/macros/tests/ui/hidden_yield.stderr index 536b038eab7..0297f68f66d 100644 --- a/rs/kio/macros/tests/ui/hidden_yield.stderr +++ b/rs/kio/macros/tests/ui/hidden_yield.stderr @@ -1,5 +1,5 @@ error: this statement runs once, so it cannot return `Poll::Pending`: wait with `let x: T = wait!(Step => poll)?;` - --> ${workspace}/rs/kio/macros/tests/ui/hidden_yield.rs:18:22 + --> tests/ui/hidden_yield.rs:18:22 | 18 | let c = std::task::ready!(self.values.poll_pop(waiter))?; | ^^^^^ diff --git a/rs/kio/macros/tests/ui/missing_try.stderr b/rs/kio/macros/tests/ui/missing_try.stderr index 8cb66bcab90..f6996844bd4 100644 --- a/rs/kio/macros/tests/ui/missing_try.stderr +++ b/rs/kio/macros/tests/ui/missing_try.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> ${workspace}/rs/kio/macros/tests/ui/missing_try.rs:18:16 + --> tests/ui/missing_try.rs:18:16 | 13 | #[kio::machine(self.state: MState)] | ----------------------------------- in this attribute macro expansion diff --git a/rs/kio/macros/tests/ui/not_send.stderr b/rs/kio/macros/tests/ui/not_send.stderr index 1d66c834f4b..d17d0647350 100644 --- a/rs/kio/macros/tests/ui/not_send.stderr +++ b/rs/kio/macros/tests/ui/not_send.stderr @@ -1,27 +1,27 @@ error[E0277]: `Rc` cannot be sent between threads safely - --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:26:16 + --> tests/ui/not_send.rs:26:16 | 26 | assert_send::(); | ^ `Rc` cannot be sent between threads safely | = help: within `M`, the trait `Send` is not implemented for `Rc` note: required because it appears within the type `MStateB` - --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:18:22 + --> tests/ui/not_send.rs:18:22 | 18 | let b: u64 = wait!(B => self.values.poll_pop(waiter))?; | ^ note: required because it appears within the type `MState` - --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:13:28 + --> tests/ui/not_send.rs:13:28 | 13 | #[kio::machine(self.state: MState)] | ^^^^^^ note: required because it appears within the type `M` - --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:7:8 + --> tests/ui/not_send.rs:7:8 | 7 | struct M { | ^ note: required by a bound in `assert_send` - --> ${workspace}/rs/kio/macros/tests/ui/not_send.rs:23:19 + --> tests/ui/not_send.rs:23:19 | 23 | fn assert_send() {} | ^^^^ required by this bound in `assert_send` diff --git a/rs/kio/macros/tests/ui/poll_moves.stderr b/rs/kio/macros/tests/ui/poll_moves.stderr index 598a82892a9..9b23b049383 100644 --- a/rs/kio/macros/tests/ui/poll_moves.stderr +++ b/rs/kio/macros/tests/ui/poll_moves.stderr @@ -1,5 +1,5 @@ error: calls to `std::mem::drop` with a reference instead of an owned value does nothing - --> ${workspace}/rs/kio/macros/tests/ui/poll_moves.rs:19:4 + --> tests/ui/poll_moves.rs:19:4 | 19 | drop(label); | ^^^^^-----^ @@ -7,7 +7,7 @@ error: calls to `std::mem::drop` with a reference instead of an owned value does | argument has type `&mut String` | note: the lint level is defined here - --> ${workspace}/rs/kio/macros/tests/ui/poll_moves.rs:13:1 + --> tests/ui/poll_moves.rs:13:1 | 13 | #[kio::machine(self.state: MState)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/rs/kio/macros/tests/ui/poll_type.stderr b/rs/kio/macros/tests/ui/poll_type.stderr index 52f6184795f..b7afe612933 100644 --- a/rs/kio/macros/tests/ui/poll_type.stderr +++ b/rs/kio/macros/tests/ui/poll_type.stderr @@ -1,15 +1,15 @@ error[E0061]: this method takes 1 argument but 0 arguments were supplied - --> ${workspace}/rs/kio/macros/tests/ui/poll_type.rs:16:39 - | - 16 | let a: u64 = wait!(A => self.values.poll_pop())?; - | ^^^^^^^^-- argument #1 of type `&Waiter` is missing - | + --> tests/ui/poll_type.rs:16:39 + | +16 | let a: u64 = wait!(A => self.values.poll_pop())?; + | ^^^^^^^^-- argument #1 of type `&Waiter` is missing + | note: method defined here - --> ${workspace}/rs/kio/src/queue.rs:185:9 - | -185 | pub fn poll_pop(&self, waiter: &Waiter) -> Poll> { - | ^^^^^^^^ + --> $WORKSPACE/rs/kio/src/queue.rs + | + | pub fn poll_pop(&self, waiter: &Waiter) -> Poll> { + | ^^^^^^^^ help: provide the argument - | - 16 | let a: u64 = wait!(A => self.values.poll_pop(/* &Waiter */))?; - | +++++++++++++ + | +16 | let a: u64 = wait!(A => self.values.poll_pop(/* &Waiter */))?; + | +++++++++++++ diff --git a/rs/kio/macros/tests/ui/segment_type.stderr b/rs/kio/macros/tests/ui/segment_type.stderr index 58f2e209d7e..cec41886aa6 100644 --- a/rs/kio/macros/tests/ui/segment_type.stderr +++ b/rs/kio/macros/tests/ui/segment_type.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> ${workspace}/rs/kio/macros/tests/ui/segment_type.rs:17:23 + --> tests/ui/segment_type.rs:17:23 | 17 | let label: String = a; | ------ ^ expected `String`, found `u64` diff --git a/rs/kio/macros/tests/ui/self_borrow.stderr b/rs/kio/macros/tests/ui/self_borrow.stderr index 995b529510e..f7d8d091af6 100644 --- a/rs/kio/macros/tests/ui/self_borrow.stderr +++ b/rs/kio/macros/tests/ui/self_borrow.stderr @@ -1,5 +1,5 @@ error: `label` lives across `wait!(B => ..)`, so it is stored in `MState::B`, which cannot hold a borrow: store an owned value, or borrow again inside the wait - --> ${workspace}/rs/kio/macros/tests/ui/self_borrow.rs:17:14 + --> tests/ui/self_borrow.rs:17:14 | 17 | let label: &kio::Queue = &self.values; | ^ diff --git a/rs/kio/macros/tests/ui/untyped.stderr b/rs/kio/macros/tests/ui/untyped.stderr index a0d1af6c730..76845f560d8 100644 --- a/rs/kio/macros/tests/ui/untyped.stderr +++ b/rs/kio/macros/tests/ui/untyped.stderr @@ -1,5 +1,5 @@ error: `label` lives across `wait!(B => ..)`, so it is stored in `MState::B`: give it a type, `let label: Type` - --> ${workspace}/rs/kio/macros/tests/ui/untyped.rs:17:7 + --> tests/ui/untyped.rs:17:7 | 17 | let label = format!("m-{a}"); | ^^^^^ diff --git a/rs/kio/macros/tests/ui/wrong_annotation.stderr b/rs/kio/macros/tests/ui/wrong_annotation.stderr index 034c74abe09..7096354e885 100644 --- a/rs/kio/macros/tests/ui/wrong_annotation.stderr +++ b/rs/kio/macros/tests/ui/wrong_annotation.stderr @@ -1,11 +1,11 @@ error[E0308]: mismatched types - --> ${workspace}/rs/kio/macros/tests/ui/wrong_annotation.rs:17:20 + --> tests/ui/wrong_annotation.rs:17:20 | 17 | let label: u32 = format!("m-{a}"); | ^^^^^^^^^^^^^^^^ expected `u32`, found `String` error[E0599]: no method named `len` found for type `u32` in the current scope - --> ${workspace}/rs/kio/macros/tests/ui/wrong_annotation.rs:19:24 + --> tests/ui/wrong_annotation.rs:19:24 | 19 | Poll::Ready(Ok(label.len() as u64 + a + b)) | ^^^ diff --git a/test/drill/mutations/subscriber-leaks-broadcasts.patch b/test/drill/mutations/subscriber-leaks-broadcasts.patch index 5a5ff59647c..f31c3f66fc2 100644 --- a/test/drill/mutations/subscriber-leaks-broadcasts.patch +++ b/test/drill/mutations/subscriber-leaks-broadcasts.patch @@ -9,9 +9,10 @@ # session is gone, so a cancelled reader's broadcast parks forever instead of # closing. Leaking only one is not a leak: the other still closes the front. diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs +index 94175c3ec6..8f07d4f860 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs -@@ -1593,7 +1593,8 @@ +@@ -1512,7 +1512,8 @@ struct PrefixRun { /// it comes from the connect config or the peer's SETUP, neither of which /// changes for the life of the session. link_cost: u64, @@ -21,16 +22,16 @@ diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber. // Lite06+: announce ids. Each received `active` implicitly assigns the next // per-stream ordinal; `ended`/`restart` reference it instead of repeating the // path, and lite-07 bases name it too. Tracked even for announces we drop -@@ -1706,7 +1707,7 @@ - let run = PrefixRun { - responder_origin, - link_cost, -- announced: Announced::new(self.subscriber.announces.clone()), -+ announced: std::mem::ManuallyDrop::new(Announced::new(self.subscriber.announces.clone())), - decoder: lite::AnnounceDecoder::default(), - auth_epoch: 0, - initial, -@@ -1842,7 +1843,8 @@ +@@ -1600,7 +1601,7 @@ impl AnnouncePrefix { + let mut run: PrefixRun = PrefixRun { + responder_origin, + link_cost, +- announced: Announced::new(self.subscriber.announces.clone()), ++ announced: std::mem::ManuallyDrop::new(Announced::new(self.subscriber.announces.clone())), + decoder: lite::AnnounceDecoder::default(), + auth_epoch: 0, + initial, +@@ -1728,7 +1729,8 @@ struct SourceServe { subscriber: Subscriber, path: Path, epoch: Option, @@ -40,7 +41,7 @@ diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber. dynamic: crate::broadcast::Requests, route: kio::Consumer<()>, // A dedicated close-watch handle, since each pending operation needs its own. -@@ -1985,7 +1987,7 @@ +@@ -1871,7 +1873,7 @@ impl SourceServe { subscriber, path: minted.path, epoch: minted.epoch,