fix(hydro_lang): remove SingletonRef global counter causing codegen non-determinism

The global `static SINGLETON_REF_COUNTER: AtomicUsize` was shared across all
tests in a binary, causing `__hydro_singleton_ref_N` idents to shift depending
on test execution order. For example, paxos snapshots expected IDs 0-6 but got
12-18 when singleton_ref tests ran first.

Fix: Remove the global counter entirely. Instead, derive the ident index from
`refs.len()` within each `with_singleton_capture` scope, so every closure's
captured singleton refs are numbered starting from 0. This is safe because each
closure gets its own lexical block in the generated code.

Changes:
- hydro_lang/src/singleton_ref.rs: Remove `SINGLETON_REF_COUNTER` static. Add
  `singleton_ref_ident(index)` helper. Simplify thread-local from
  `Vec<(syn::Ident, HydroNode)>` to `Vec<HydroNode>`. Use `refs.len()` as index.
- hydro_lang/src/compile/ir/mod.rs: Change `ClosureExpr::singleton_refs` from
  `Vec<(syn::Ident, HydroNode)>` to `Vec<HydroNode>`. Update Clone, Serialize,
  deep_clone, transform_children, and emit_tokens to use index-based idents via
  the new helper.
- hydro_test snapshots: Regenerated paxos IR and mermaid snapshots (stable only;
  nightly snapshots need a nightly CI run).

Co-authored-by: Infinity 🤖 <infinity@hydro.run>

Author: MingweiSamuel

hydro_lang/src/compile/ir/mod.rs

@@ -43,7 +43,7 @@ use backtrace::Backtrace;
 /// captures, which is important for nodes with multiple closures (e.g. Fold has `init` and `acc`).
 pub struct ClosureExpr {
     pub expr: DebugExpr,
-    pub singleton_refs: Vec<(syn::Ident, HydroNode)>,
+    pub singleton_refs: Vec<HydroNode>,
 }
 
 impl Clone for ClosureExpr {
@@ -53,15 +53,12 @@ impl Clone for ClosureExpr {
             singleton_refs: self
                 .singleton_refs
                 .iter()
-                .map(|(ident, node)| {
-                    let cloned_node = match node {
-                        HydroNode::Singleton { inner, metadata } => HydroNode::Singleton {
-                            inner: SharedNode(inner.0.clone()),
-                            metadata: metadata.clone(),
-                        },
-                        _ => panic!("singleton_refs should only contain HydroNode::Singleton"),
-                    };
-                    (ident.clone(), cloned_node)
+                .map(|node| match node {
+                    HydroNode::Singleton { inner, metadata } => HydroNode::Singleton {
+                        inner: SharedNode(inner.0.clone()),
+                        metadata: metadata.clone(),
+                    },
+                    _ => panic!("singleton_refs should only contain HydroNode::Singleton"),
                 })
                 .collect(),
         }
@@ -90,14 +87,17 @@ impl serde::Serialize for ClosureExpr {
     }
 }
 
-struct SerializableSingletonRefs<'a>(&'a [(syn::Ident, HydroNode)]);
+struct SerializableSingletonRefs<'a>(&'a [HydroNode]);
 
 impl serde::Serialize for SerializableSingletonRefs<'_> {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         use serde::ser::SerializeSeq;
         let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
-        for (ident, node) in self.0 {
-            seq.serialize_element(&(ident.to_string(), node))?;
+        for (i, node) in self.0.iter().enumerate() {
+            seq.serialize_element(&(
+                crate::singleton_ref::singleton_ref_ident(i).to_string(),
+                node,
+            ))?;
         }
         seq.end()
     }
@@ -134,7 +134,7 @@ impl From<DebugExpr> for ClosureExpr {
 }
 
 impl ClosureExpr {
-    pub fn new(expr: DebugExpr, singleton_refs: Vec<(syn::Ident, HydroNode)>) -> Self {
+    pub fn new(expr: DebugExpr, singleton_refs: Vec<HydroNode>) -> Self {
         Self {
             expr,
             singleton_refs,
@@ -147,7 +147,7 @@ impl ClosureExpr {
             singleton_refs: self
                 .singleton_refs
                 .iter()
-                .map(|(ident, node)| (ident.clone(), node.deep_clone(seen_tees)))
+                .map(|node| node.deep_clone(seen_tees))
                 .collect(),
         }
     }
@@ -157,7 +157,7 @@ impl ClosureExpr {
         transform: &mut impl FnMut(&mut HydroNode, &mut SeenSharedNodes),
         seen_tees: &mut SeenSharedNodes,
     ) {
-        for (_ident, ref_node) in self.singleton_refs.iter_mut() {
+        for ref_node in self.singleton_refs.iter_mut() {
             transform(ref_node, seen_tees);
         }
     }
@@ -175,10 +175,8 @@ impl ClosureExpr {
                 .into_iter()
                 .rev()
                 .collect::<Vec<_>>();
-            let local_idents = self
-                .singleton_refs
-                .iter()
-                .map(|(local_ident, _)| local_ident);
+            let local_idents = (0..self.singleton_refs.len())
+                .map(crate::singleton_ref::singleton_ref_ident);
             let hash = proc_macro2::Punct::new('#', proc_macro2::Spacing::Alone);
             let expr = &self.expr.0;
             quote! {

hydro_lang/src/singleton_ref.rs

@@ -41,9 +41,18 @@ impl<T, L> Clone for SingletonRef<'_, '_, T, L> {
 }
 
 // Thread-local storage for singleton references captured during `q!()` expansion.
-// Maps local ident name -> SharedNode for each singleton captured in the current closure.
+// Stores the HydroNode for each singleton captured in the current closure.
+// The index in the Vec determines the ident name via `singleton_ref_ident`.
 thread_local! {
-    static SINGLETON_REFS: RefCell<Option<Vec<(syn::Ident, HydroNode)>>> = const { RefCell::new(None) };
+    static SINGLETON_REFS: RefCell<Option<Vec<HydroNode>>> = const { RefCell::new(None) };
+}
+
+/// Returns the canonical ident for a singleton ref at the given index within a closure.
+pub(crate) fn singleton_ref_ident(index: usize) -> syn::Ident {
+    syn::Ident::new(
+        &format!("__hydro_singleton_ref_{}", index),
+        Span::call_site(),
+    )
 }
 
 /// Activate the singleton reference capture context. Must be called before `q!()` expansion
@@ -64,26 +73,23 @@ pub fn with_singleton_capture(
     crate::compile::ir::ClosureExpr::new(expr, singleton_refs)
 }
 
-static SINGLETON_REF_COUNTER: std::sync::atomic::AtomicUsize =
-    std::sync::atomic::AtomicUsize::new(0);
-
 impl<'a, 'slf, T: 'a, L> FreeVariableWithContextWithProps<L, ()> for SingletonRef<'a, 'slf, T, L>
 where
     L: Location<'a>,
 {
     type O = &'a T;
 
     fn to_tokens(self, _ctx: &L) -> (QuoteTokens, ()) {
-        let id = SINGLETON_REF_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let ident = syn::Ident::new(&format!("__hydro_singleton_ref_{}", id), Span::call_site());
-
-        SINGLETON_REFS.with(|cell| {
+        let ident = SINGLETON_REFS.with(|cell| {
             let mut guard = cell.borrow_mut();
             let refs = guard.as_mut().expect(
                 "SingletonRef used inside q!() but no singleton capture scope is active. \
                  This is a bug — singleton capture should be set up by the operator that uses q!().",
             );
 
+            let index = refs.len();
+            let ident = singleton_ref_ident(index);
+
             let metadata = self.ir_node.borrow().metadata().clone();
 
             // Wrap in HydroNode::Singleton for materialization + identity tracking. If already a Singleton node,
@@ -101,13 +107,12 @@ where
                 unreachable!()
             };
 
-            refs.push((
-                ident.clone(),
-                HydroNode::Singleton {
-                    inner: SharedNode(Rc::clone(&inner.0)),
-                    metadata,
-                },
-            ));
+            refs.push(HydroNode::Singleton {
+                inner: SharedNode(Rc::clone(&inner.0)),
+                metadata,
+            });
+
+            ident
         });
 
         (