refactor(tracker): require debug symbols at construction time

revert some changes to tracker tests.

Author: stringhandler

src/tracker.rs

@@ -71,35 +71,36 @@ fn default_warning_sink(message: &str) {
 ///
 /// This tracker extends [`SetTracker`] with SimplicityHL-specific functionality:
 ///
-/// - Optionally traces jet invocations with decoded arguments and return values.
 /// - Decodes and forwards `dbg!()` calls to a configurable sink, using
-///   debug symbols supplied via [`with_debug_symbols`](DefaultTracker::with_debug_symbols).
+///   the provided [`DebugSymbols`] to resolve CMRs to debug information.
+/// - Optionally traces jet invocations with decoded arguments and return values.
 ///
 /// # Example
 ///
 /// ```rust,ignore
-/// let tracker = DefaultTracker::new()
-///     .with_debug_symbols(&debug_symbols)
+/// let tracker = DefaultTracker::new(&debug_symbols)
 ///     .with_log_level(TrackerLogLevel::Debug);
 ///
 /// let pruned = program.prune_with_tracker(&env, &mut tracker)?;
 /// ```
-#[derive(Default)]
 pub struct DefaultTracker<'a> {
-    debug_symbols: Option<&'a DebugSymbols>,
+    debug_symbols: &'a DebugSymbols,
     debug_sink: Option<DebugSink<'a>>,
     jet_trace_sink: Option<JetTraceSink<'a>>,
     warning_sink: Option<WarningSink<'a>>,
     inner: SetTracker,
 }
 
 impl<'a> DefaultTracker<'a> {
-    /// Supplies the debug symbol table needed to decode `dbg!()` calls.
-    ///
-    /// Required when using any debug sink; has no effect otherwise.
-    pub fn with_debug_symbols(mut self, debug_symbols: &'a DebugSymbols) -> Self {
-        self.debug_symbols = Some(debug_symbols);
-        self
+    /// Creates a new tracker bound to the given debug symbol table.
+    pub fn new(debug_symbols: &'a DebugSymbols) -> Self {
+        Self {
+            debug_symbols,
+            debug_sink: None,
+            jet_trace_sink: None,
+            warning_sink: None,
+            inner: SetTracker::default(),
+        }
     }
 
     /// Enables forwarding of `debug!()` calls to the provided sink.
@@ -184,6 +185,11 @@ impl<'a> DefaultTracker<'a> {
 
         let mut input_frame = input.clone();
 
+        // The reason we need to advance by a bit is that the AssertL combinator is actually a Case combinator,
+        // which takes a bit of input to decide which branch to take. But this bit is "meaningless" and
+        // is always 0 because it's an assertion.
+        let _ = input_frame.next();
+
         let args = match parse_jet_arguments(jet, &mut input_frame) {
             Ok(args) => args,
             Err(e) => {
@@ -213,6 +219,13 @@ impl<'a> DefaultTracker<'a> {
                 let target_ty = &node.arrow().target;
                 let jet_target_ty = resolve_jet_type(&target_type(jet));
 
+                // Skip the leading bit when the frame has extra padding.
+                // This occurs because some jets (like eq_64 etc.) are wrapped in AssertL (a Case combinator),
+                // see compile::with_debug_symbol
+                if target_ty.as_sum().is_some() {
+                    let _ = output_frame.next();
+                }
+
                 let output_value = SimValue::from_padded_bits(&mut output_frame, target_ty)
                     .expect("output from bit machine is always well-formed");
 
@@ -235,12 +248,7 @@ impl<'a> DefaultTracker<'a> {
             return;
         }
 
-        let Some(debug_symbols) = self.debug_symbols else {
-            self.warn("Debug sink set but no debug symbols provided");
-            return;
-        };
-
-        let Some(tracked_call) = debug_symbols.get(cmr) else {
+        let Some(tracked_call) = self.debug_symbols.get(cmr) else {
             self.warn(&format!("Unknown debug symbol: CMR {cmr}"));
             return;
         };
@@ -251,9 +259,7 @@ impl<'a> DefaultTracker<'a> {
 
         let mut input_frame = input.clone();
 
-        // AssertL is a Case combinator, which reads one selector bit before passing
-        // the remainder to its child. The tracker sees the full frame at the AssertL
-        // node, so skip that bit to reach the actual value.
+        // Skip the Case combinator's branch selection bit (see handle_jet).
         let _ = input_frame.next();
 
         // The debug call has signature `dbg!(T) -> T`, so the target type
@@ -398,8 +404,7 @@ mod tests {
         let debug_clone = debug_store.clone();
         let jet_clone = jet_store.clone();
 
-        let tracker = DefaultTracker::default()
-            .with_debug_symbols(debug_symbols)
+        let tracker = DefaultTracker::new(debug_symbols)
             .with_debug_sink(move |label, value| {
                 debug_clone
                     .borrow_mut()
@@ -418,23 +423,6 @@ mod tests {
         (tracker, debug_store, jet_store)
     }
 
-    fn create_jet_tracker() -> (DefaultTracker<'static>, JetStore) {
-        let jet_store: JetStore = Rc::default();
-        let jet_clone = jet_store.clone();
-
-        let tracker = DefaultTracker::default().with_jet_trace_sink(move |jet, args, result| {
-            jet_clone.borrow_mut().insert(
-                jet.to_string(),
-                (
-                    args.map(|a| a.iter().map(|v| v.to_string()).collect()),
-                    result.map(|r| r.to_string()),
-                ),
-            );
-        });
-
-        (tracker, jet_store)
-    }
-
     fn create_test_env() -> ElementsEnv<Arc<elements::Transaction>> {
         let mut tx = PartiallySignedTransaction::new_v2();
         let outpoint = OutPoint::new(Txid::from_slice(&[2; 32]).unwrap(), 33);
@@ -530,7 +518,7 @@ mod tests {
         let program = program.instantiate(Arguments::default(), true).unwrap();
         let satisfied = program.satisfy(WitnessValues::default()).unwrap();
 
-        let (mut tracker, jet_store) = create_jet_tracker();
+        let (mut tracker, _, jet_store) = create_test_tracker(&satisfied.debug_symbols);
 
         let _ = satisfied.redeem().prune_with_tracker(&env, &mut tracker);
 
@@ -584,7 +572,7 @@ mod tests {
         let program = program.instantiate(Arguments::default(), true).unwrap();
         let satisfied = program.satisfy(WitnessValues::default()).unwrap();
 
-        let (mut tracker, jet_store) = create_jet_tracker();
+        let (mut tracker, _, jet_store) = create_test_tracker(&satisfied.debug_symbols);
 
         let _ = satisfied.redeem().prune_with_tracker(&env, &mut tracker);