Tracker can spuriously report "Unknown debug symbol"

[schoen]

Project version

0.7.2

Project

core

What happened?

In the runnable-snippets logic for the web site, some programs (but not all) that run successfully would display an inexplicable warning Unknown debug symbol, while still executing correctly.

I've worked around this in runnable-snippets by simply hiding this message wherever it occurs, but an AI concluded that this is a tracker bug, having to do with DefaultTracker::visit_node in src/tracker.rs.

Minimal reproduction steps

//! Standalone, narrated reproduction of a bug in `DefaultTracker`
//! (src/tracker.rs): it reports "Unknown debug symbol: CMR <hex>" for
//! programs that contain no `dbg!()` call at all, and does so
//! inconsistently -- for one of two structurally-symmetric operations, but
//! not the other -- purely depending on internal branch-canonicalization
//! details the program author has no visibility into or control over.
//!
//! Root cause: `DefaultTracker::visit_node`'s `ExecTracker` impl only
//! inspects `Inner::AssertL` nodes when deciding whether to run
//! `handle_debug`; there is no matching arm for `Inner::AssertR`. Two
//! unrelated Simplicity constructs produce untracked assert nodes of
//! exactly this shape:
//!
//!   1. `unwrap_left::<T>()` compiles via `assertl_take` into an `AssertL`
//!      carrying a fixed, deliberately-untracked sentinel CMR
//!      (`Cmr::fail(FailEntropy::ZERO)`). `unwrap()`/`unwrap_right::<T>()`
//!      compile via `assertr_take` into the very same kind of sentinel,
//!      but as an `AssertR`. (src/compile/mod.rs:406-425)
//!
//!   2. Pruning a redeemed program (`RedeemNode::prune`/
//!      `prune_with_tracker`, in the simplicity-lang dependency) collapses
//!      any single-resolution `match` into `Inner::AssertL` or
//!      `Inner::AssertR`, depending only on which side survived -- again,
//!      neither CMR is ever a tracked call.
//!
//! In both cases, the *identical kind* of untracked node is diagnosed for
//! one side and silently ignored for the other.
//!
//! No dbg!() appears anywhere in the four small programs below. Run with:
//!
//!     cargo run --example debug_symbol_warning_repro

use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;

use simplicityhl::ast::ElementsJetHinter;
use simplicityhl::elements;
use simplicityhl::elements::confidential::{Asset, Value};
use simplicityhl::elements::hashes::Hash;
use simplicityhl::elements::pset::{Input, PartiallySignedTransaction};
use simplicityhl::elements::taproot::ControlBlock;
use simplicityhl::elements::{AssetId, BlockHash, LockTime, OutPoint, Script, Sequence, Txid};
use simplicityhl::tracker::DefaultTracker;
use simplicityhl::{Arguments, TemplateAst, WitnessValues};

type ElementsEnv = simplicity::jet::elements::ElementsEnv<Arc<elements::Transaction>>;

fn env_with_lock_time(lock_time: LockTime) -> ElementsEnv {
    simplicityhl::dummy_env::dummy_with(lock_time, Sequence::MAX, false)
}

/// A UTXO with an explicit (non-null) asset and value, so that
/// `jet::input_amount(0)` deterministically returns `Some(..)`.
fn env_with_explicit_input_amount() -> ElementsEnv {
    let mut tx = PartiallySignedTransaction::new_v2();
    let outpoint = OutPoint::new(Txid::from_slice(&[2; 32]).unwrap(), 33);
    tx.add_input(Input::from_prevout(outpoint));

    simplicity::jet::elements::ElementsEnv::new(
        Arc::new(tx.extract_tx().unwrap()),
        vec![simplicity::jet::elements::ElementsUtxo {
            script_pubkey: Script::new(),
            asset: Asset::Explicit(AssetId::LIQUID_BTC),
            value: Value::Explicit(1000),
        }],
        0,
        simplicity::Cmr::from_byte_array([0; 32]),
        ControlBlock::from_slice(&[0xc0; 33]).unwrap(),
        None,
        BlockHash::all_zeros(),
    )
}

fn run_unpruned_and_collect_warnings(source: &str, env: &ElementsEnv) -> Vec<String> {
    let program = TemplateAst::new(source, Box::new(ElementsJetHinter::new())).unwrap();
    let compiled = program.instantiate(Arguments::default(), true).unwrap();
    let satisfied = compiled.satisfy(WitnessValues::default()).unwrap();

    let warnings: Rc<RefCell<Vec<String>>> = Rc::default();
    let warnings_clone = warnings.clone();
    let mut tracker = DefaultTracker::build(
        satisfied.debug_symbols(),
        Box::new(ElementsJetHinter::new()),
    )
    .with_debug_sink(|_, _| {})
    .with_warning_sink(move |msg| warnings_clone.borrow_mut().push(msg.to_string()));

    satisfied
        .redeem()
        .prune_with_tracker(env, &mut tracker)
        .unwrap();

    let result = warnings.borrow().clone();
    result
}

fn run_pruned_and_collect_warnings(source: &str, env: &ElementsEnv) -> Vec<String> {
    let program = TemplateAst::new(source, Box::new(ElementsJetHinter::new())).unwrap();
    let compiled = program.instantiate(Arguments::default(), true).unwrap();

    // Satisfy *with* an environment: this prunes the tree, collapsing the
    // single-resolution match into an AssertL/AssertR node up front.
    let satisfied = compiled
        .satisfy_with_env(WitnessValues::default(), Some(env))
        .unwrap();

    let warnings: Rc<RefCell<Vec<String>>> = Rc::default();
    let warnings_clone = warnings.clone();
    let mut tracker = DefaultTracker::build(
        satisfied.debug_symbols(),
        Box::new(ElementsJetHinter::new()),
    )
    .with_debug_sink(|_, _| {})
    .with_warning_sink(move |msg| warnings_clone.borrow_mut().push(msg.to_string()));

    // Interpret the already-pruned tree again, as a harness would to
    // collect an execution trace for display.
    satisfied
        .redeem()
        .prune_with_tracker(env, &mut tracker)
        .unwrap();

    let result = warnings.borrow().clone();
    result
}

fn report(label: &str, source: &str, warnings: &[String]) {
    println!("--- {label} ---");
    println!("{}", source.trim());
    if warnings.is_empty() {
        println!(">> No warnings. (clean)");
    } else {
        println!(">> Warnings emitted:");
        for w in warnings {
            println!("   {w}");
        }
    }
    println!();
}

fn main() {
    println!(
        "Reproducing a DefaultTracker bug: spurious \"Unknown debug symbol\" \
         warnings with no dbg!() anywhere, appearing for one of two \
         structurally-symmetric operations but not the other.\n"
    );

    // --- Mechanism 1: unwrap_left vs. unwrap_right --------------------
    println!("=== Mechanism 1: unwrap_left vs. unwrap_right ===\n");

    const UNWRAP_LEFT_ONLY: &str = r#"
        fn main() {
            let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
            let _h: Height = unwrap_left::<Time>(x);
        }
    "#;
    const UNWRAP_RIGHT_ONLY: &str = r#"
        fn main() {
            let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
            let _t: Time = unwrap_right::<Height>(x);
        }
    "#;

    // lock_time = 0 -> Left(Height(0)), so `unwrap_left` succeeds.
    let left_warnings =
        run_unpruned_and_collect_warnings(UNWRAP_LEFT_ONLY, &env_with_lock_time(LockTime::ZERO));
    report("unwrap_left::<Time>(x)", UNWRAP_LEFT_ONLY, &left_warnings);

    // lock_time = 600_000_000 -> Right(Time(600000000)), so `unwrap_right` succeeds.
    let right_warnings = run_unpruned_and_collect_warnings(
        UNWRAP_RIGHT_ONLY,
        &env_with_lock_time(LockTime::from_consensus(600_000_000)),
    );
    report(
        "unwrap_right::<Height>(x)  (same operation, opposite side)",
        UNWRAP_RIGHT_ONLY,
        &right_warnings,
    );

    // --- Mechanism 2: pruned match arms --------------------------------
    println!("=== Mechanism 2: which side of a pruned match survives ===\n");

    const BOOL_MATCH_TAKES_LEFT_ARM: &str = r#"
        fn main() {
            let bit_flip: bool = match false {
                false => true,
                true => false,
            };
            assert!(bit_flip);
        }
    "#;
    const OPTION_MATCH_TAKES_RIGHT_ARM: &str = r#"
        fn main() {
            match jet::input_amount(0) {
                None => {},
                Some(_pair: (Asset1, Amount1)) => {},
            }
        }
    "#;

    let input_amount_env = env_with_explicit_input_amount();

    let bool_warnings =
        run_pruned_and_collect_warnings(BOOL_MATCH_TAKES_LEFT_ARM, &input_amount_env);
    report(
        "match false { .. }  (resolves to its canonically-left arm)",
        BOOL_MATCH_TAKES_LEFT_ARM,
        &bool_warnings,
    );

    let option_warnings =
        run_pruned_and_collect_warnings(OPTION_MATCH_TAKES_RIGHT_ARM, &input_amount_env);
    report(
        "match jet::input_amount(0) { .. }  (resolves to its canonically-right arm)",
        OPTION_MATCH_TAKES_RIGHT_ARM,
        &option_warnings,
    );

    println!(
        "Conclusion: none of the four programs above contain dbg!(). Yet \
         \"unwrap_left\" and the bool match both spuriously warn, while their \
         structural twins (\"unwrap_right\" and the Option match) stay silent. \
         See DefaultTracker::visit_node in src/tracker.rs: it only inspects \
         Inner::AssertL, never Inner::AssertR."
    );
}

[schoen]

I also got two tests for cargo tests

//! Demonstrates that pruning a `match` (RedeemNode::prune /
//! prune_with_tracker, in the simplicity-lang dependency) is diagnosed
//! inconsistently by `DefaultTracker`, depending only on *which side*
//! of the match survives -- not on whether the surviving structure is
//! actually untracked (it never is, in either case).
//!
//! Pruning collapses a `Case` node whose sibling branch went unused into:
//!   - `Inner::AssertL` when the *canonically-left* arm (`None`/`Left`/
//!     `false`) is the one that executed (the canonically-right arm,
//!     `Some`/`Right`/`true`, is discarded and its CMR becomes the
//!     AssertL's tag).
//!   - `Inner::AssertR` when the *canonically-right* arm executed instead
//!     (mirror image).
//! (See simplicity-lang's node/mod.rs, `Hide::Left`/`Hide::Right`.)
//! `DefaultTracker::visit_node` only ever inspects `Inner::AssertL`.
//!
//! Neither program below contains `dbg!()`. Both are single-resolution
//! matches, run exactly once, that unconditionally resolve to one specific
//! side. Only one of them warns -- purely because of which side that is.
//!
//! This test passes today. That passing is the bug report.
//!
//! Run with: cargo test --test bug_untracked_assert_asymmetry_match -- --nocapture

use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;

use simplicityhl::ast::ElementsJetHinter;
use simplicityhl::elements;
use simplicityhl::elements::confidential::{Asset, Value};
use simplicityhl::elements::hashes::Hash;
use simplicityhl::elements::pset::{Input, PartiallySignedTransaction};
use simplicityhl::elements::taproot::ControlBlock;
use simplicityhl::elements::{AssetId, BlockHash, OutPoint, Script, Txid};
use simplicityhl::tracker::DefaultTracker;
use simplicityhl::{Arguments, TemplateAst, WitnessValues};

/// Resolves to its canonically-*left* arm (`false`). The discarded `true`
/// arm becomes an `Inner::AssertL` -- which the tracker checks.
const BOOL_MATCH_TAKES_LEFT_ARM: &str = r#"
    fn main() {
        let bit_flip: bool = match false {
            false => true,
            true => false,
        };
        assert!(bit_flip);
    }
"#;

/// Resolves to its canonically-*right* arm (`Some`). The discarded `None`
/// arm becomes an `Inner::AssertR` -- which the tracker never checks.
const OPTION_MATCH_TAKES_RIGHT_ARM: &str = r#"
    fn main() {
        match jet::input_amount(0) {
            None => {},
            Some(_pair: (Asset1, Amount1)) => {},
        }
    }
"#;

/// A UTXO with an explicit (non-null) asset and value, so that
/// `jet::input_amount(0)` deterministically returns `Some(..)`.
fn env_with_explicit_input_amount(
) -> simplicity::jet::elements::ElementsEnv<Arc<elements::Transaction>> {
    let mut tx = PartiallySignedTransaction::new_v2();
    let outpoint = OutPoint::new(Txid::from_slice(&[2; 32]).unwrap(), 33);
    tx.add_input(Input::from_prevout(outpoint));

    simplicity::jet::elements::ElementsEnv::new(
        Arc::new(tx.extract_tx().unwrap()),
        vec![simplicity::jet::elements::ElementsUtxo {
            script_pubkey: Script::new(),
            asset: Asset::Explicit(AssetId::LIQUID_BTC),
            value: Value::Explicit(1000),
        }],
        0,
        simplicity::Cmr::from_byte_array([0; 32]),
        ControlBlock::from_slice(&[0xc0; 33]).unwrap(),
        None,
        BlockHash::all_zeros(),
    )
}

fn run_and_collect_warnings(
    source: &str,
    env: &simplicity::jet::elements::ElementsEnv<Arc<elements::Transaction>>,
) -> Vec<String> {
    let program = TemplateAst::new(source, Box::new(ElementsJetHinter::new())).unwrap();
    let compiled = program.instantiate(Arguments::default(), true).unwrap();

    // Satisfy *with* an environment: this prunes the tree, collapsing the
    // single-resolution match into an AssertL/AssertR node.
    let satisfied = compiled
        .satisfy_with_env(WitnessValues::default(), Some(env))
        .unwrap();

    let warnings: Rc<RefCell<Vec<String>>> = Rc::default();
    let warnings_clone = warnings.clone();

    let mut tracker = DefaultTracker::build(
        satisfied.debug_symbols(),
        Box::new(ElementsJetHinter::new()),
    )
    .with_debug_sink(|_, _| {})
    .with_warning_sink(move |msg| warnings_clone.borrow_mut().push(msg.to_string()));

    // Interpret the already-pruned tree again, as a harness would do to
    // collect an execution trace for display.
    satisfied
        .redeem()
        .prune_with_tracker(env, &mut tracker)
        .unwrap();

    let result = warnings.borrow().clone();
    result
}

#[test]
fn matches_are_diagnosed_inconsistently_depending_on_which_side_survives() {
    let env = env_with_explicit_input_amount();

    let bool_warnings = run_and_collect_warnings(BOOL_MATCH_TAKES_LEFT_ARM, &env);
    let option_warnings = run_and_collect_warnings(OPTION_MATCH_TAKES_RIGHT_ARM, &env);

    assert!(
        bool_warnings
            .iter()
            .any(|w| w.contains("Unknown debug symbol")),
        "expected the match on `false` (canonically-left arm survives) to \
         spuriously warn (current, buggy behavior): {bool_warnings:?}"
    );
    assert!(
        option_warnings.is_empty(),
        "expected the match on `Some(..)` (canonically-right arm survives) \
         to NOT warn (also current, buggy behavior), even though it is the \
         same kind of pruned, untracked assert node as the bool match \
         above: {option_warnings:?}"
    );
}

and

//! Demonstrates that `DefaultTracker` (src/tracker.rs) diagnoses
//! `unwrap_left` and `unwrap_right` inconsistently, even though they are
//! structurally symmetric operations: both extract the payload of an
//! `Either`, asserting it is the expected side.
//!
//! `unwrap_left::<T>()` compiles via `assertl_take` into an `Inner::AssertL`
//! (compile/mod.rs:406-415). `unwrap()`/`unwrap_right::<T>()` compile via
//! `assertr_take` into an `Inner::AssertR` (compile/mod.rs:416-424). Both
//! embed the same fixed, deliberately-untracked sentinel CMR
//! (`Cmr::fail(FailEntropy::ZERO)`) -- neither is ever present in
//! `DebugSymbols`, by design, since neither is a tracked call.
//!
//! `DefaultTracker::visit_node`'s `ExecTracker` impl only inspects
//! `Inner::AssertL` when deciding whether to run `handle_debug`; there is
//! no matching arm for `Inner::AssertR`. So the *same kind* of untracked
//! node is reported as an "Unknown debug symbol" warning for one of these
//! two calls and silently ignored for the other, purely depending on which
//! side of the `Either` is being extracted -- not on anything relevant to
//! whether the program actually contains a `dbg!()` or a real symbol-table
//! mismatch (neither program below has either).
//!
//! This test passes today. That passing is the bug report: it shows two
//! operations that should be diagnostically identical are not.
//!
//! Run with: cargo test --test bug_untracked_assert_asymmetry_unwrap -- --nocapture

use std::cell::RefCell;
use std::rc::Rc;

use simplicityhl::ast::ElementsJetHinter;
use simplicityhl::dummy_env;
use simplicityhl::elements::LockTime;
use simplicityhl::tracker::DefaultTracker;
use simplicityhl::{Arguments, TemplateAst, WitnessValues};

// `jet::parse_lock` always returns `Either<Height, Time>`: locktimes below
// 500,000,000 decode as `Left(Height)`, at or above decode as `Right(Time)`.
const UNWRAP_LEFT_ONLY: &str = r#"
    fn main() {
        let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
        let _h: Height = unwrap_left::<Time>(x);
    }
"#;

const UNWRAP_RIGHT_ONLY: &str = r#"
    fn main() {
        let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
        let _t: Time = unwrap_right::<Height>(x);
    }
"#;

fn run_and_collect_warnings(source: &str, lock_time: LockTime) -> Vec<String> {
    let program = TemplateAst::new(source, Box::new(ElementsJetHinter::new())).unwrap();
    let compiled = program.instantiate(Arguments::default(), true).unwrap();
    let satisfied = compiled.satisfy(WitnessValues::default()).unwrap();

    let warnings: Rc<RefCell<Vec<String>>> = Rc::default();
    let warnings_clone = warnings.clone();

    let mut tracker = DefaultTracker::build(
        satisfied.debug_symbols(),
        Box::new(ElementsJetHinter::new()),
    )
    .with_debug_sink(|_, _| {})
    .with_warning_sink(move |msg| warnings_clone.borrow_mut().push(msg.to_string()));

    let env = dummy_env::dummy_with(lock_time, simplicityhl::elements::Sequence::MAX, false);
    satisfied
        .redeem()
        .prune_with_tracker(&env, &mut tracker)
        .unwrap();

    let result = warnings.borrow().clone();
    result
}

#[test]
fn unwrap_left_and_unwrap_right_are_diagnosed_inconsistently() {
    // lock_time = 0 -> Left(Height(0)), so `unwrap_left` succeeds.
    let left_warnings = run_and_collect_warnings(UNWRAP_LEFT_ONLY, LockTime::ZERO);
    // lock_time = 600_000_000 -> Right(Time(600000000)), so `unwrap_right` succeeds.
    let right_warnings =
        run_and_collect_warnings(UNWRAP_RIGHT_ONLY, LockTime::from_consensus(600_000_000));

    assert!(
        left_warnings
            .iter()
            .any(|w| w.contains("Unknown debug symbol")),
        "expected unwrap_left to spuriously warn (this reflects current, \
         buggy behavior): {left_warnings:?}"
    );
    assert!(
        right_warnings.is_empty(),
        "expected unwrap_right to NOT warn (also current, buggy behavior). \
         unwrap_left and unwrap_right are structurally symmetric operations; \
         they should not be diagnosed differently: {right_warnings:?}"
    );
}

[schoen]

Possibly annoyingly confident overall AI-generated explanation of what it thinks is the root cause:

AI explanation of the DefaultTracker behavior

## Summary

DefaultTracker::visit_node (src/tracker.rs) only inspects Inner::AssertL
nodes when deciding whether to run handle_debug:

impl ExecTracker for DefaultTracker<'_> {
    fn visit_node(&mut self, node: &RedeemNode, input: FrameIter, output: NodeOutput) {
        match node.inner() {
            Inner::Jet(jet) => { ... }
            Inner::AssertL(_, cmr) => self.handle_debug(node, &input, cmr),
            _ => {}
        }
        ...

There is no arm for Inner::AssertR(l_cmr, _). Combined with handle_debug's
behavior of warning "Unknown debug symbol: CMR {cmr}" whenever a CMR isn't
in debug_symbols (src/tracker.rs:251-253), this produces false-positive
warnings that have nothing to do with dbg!(), via two independent
mechanisms.

Mechanism 1: unwrap_left vs. unwrap/unwrap_right

unwrap_left::<T>() compiles via assertl_take (src/compile/mod.rs:406-415)
into an AssertL carrying the sentinel CMR Cmr::fail(FailEntropy::ZERO),
which is never registered in debug_symbols (it isn't a tracked call, just
a structural implementation detail of how unwrap_left extracts its payload).
unwrap()/unwrap_right::<T>() compile via assertr_take
(src/compile/mod.rs:416-424) into the same kind of sentinel, but as an
AssertR.

Both are the same untracked, by-design sentinel. Only one of them is ever
checked:

// A: warns "Unknown debug symbol", despite no dbg!() anywhere
let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
let _h: Height = unwrap_left::<Time>(x);

// B: does not warn -- structurally identical operation, opposite side
let x: Either<Height, Time> = jet::parse_lock(jet::lock_time());
let _t: Time = unwrap_right::<Height>(x);

Reproduction: tests/bug_untracked_assert_asymmetry_unwrap.rs. This test
passes on the current code -- that's the bug report: it directly asserts
that these two structurally-symmetric operations are diagnosed differently.

Mechanism 2: pruned match arms

More broadly: pruning a RedeemNode (RedeemNode::prune/prune_with_tracker,
upstream in the simplicity-lang dependency) collapses any Case node whose
sibling branch went unused into:

• Inner::AssertL(left, right.cmr()) when the canonically-left arm
  (None/Left/false) is the one that executed, or
• Inner::AssertR(left.cmr(), right) when the canonically-right arm
  (Some/Right/true) executed instead

(see simplicity-lang's node/mod.rs, Hide::Left/Hide::Right handling).
Neither CMR is ever in debug_symbols -- they're just hashes of whichever
code got pruned away, not tracked calls.

Note that the warning surfaces on a later pass, not during pruning itself.
While prune_with_tracker executes an unpruned tree, visit_node sees
Inner::Case -- the AssertL does not exist yet. The spurious warning appears
when the already-pruned tree is executed again under a tracker, which is the
normal shape of a redemption-time or replay run (and what
tests/bug_untracked_assert_asymmetry_match.rs does: satisfy_with_env(..)
to prune, then prune_with_tracker on the result).

So the rule is: any match whose executions all took the None/Left/false
side is pruned to an AssertL, and then warns on every subsequent traced run:

// warns: takes the canonically-left arm, so the discarded `true` arm
// becomes AssertL
match false {
    false => true,
    true => false,
};

// does not warn: takes the canonically-right arm, so the discarded `None`
// arm becomes AssertR
match some_option {
    None => 0,
    Some(x) => x,
};

Reproduction: tests/bug_untracked_assert_asymmetry_match.rs. Also passes
today, for the same reason.

Why this matters beyond the message text

Because the check only fires on AssertL, the warning appears for some
untracked asserts and not others, seemingly at random from a user's
perspective -- it depends on branch canonicalization they have no visibility
into. That makes it look like a targeting/detection bug rather than what it
actually is: the check is unconditionally wrong for any untracked
AssertL/AssertR, and the missing AssertR arm is currently hiding some of
the false positives, not preventing them.

The split is even by mechanism but not by incidence, so "half the cases" is
the wrong mental model for how often users see it:

• In the unwrap family, unwrap() and unwrap_right::<T>() both compile
  through assertr_take, so unwrap_left::<T>() -- much the rarest of the
  three in practice -- is the only one that warns.
• In pruned matches it falls out of whichever arms happened to be canonically
  left, which is program-dependent.

Separately, the entire path is gated on debug_sink.is_some()
(src/tracker.rs:247), so a tracker configured with a warning sink but no
debug sink stays silent regardless. That coupling -- warnings about debug
symbols suppressed unless someone is listening for debug output -- is
arguably its own small smell, but it is not the bug reported here.

Please do not fix this by just adding the missing Inner::AssertR arm.
Two reasons:

1. It would make every currently-silent case start warning too, roughly
   doubling the false-positive rate instead of fixing it.
2. As a dbg!()-detection site, an AssertR arm would be dead code by
   construction. The only place in the crate that ever attaches a tracked CMR
   to an assert node is assertl_drop in Scope::with_debug_symbol
   (src/compile/mod.rs:212); the only other assert constructions are the
   assertl_take/assertr_take calls at 409/419, which both pass the
   untracked Cmr::fail(FailEntropy::ZERO) sentinel. A debug symbol therefore
   cannot structurally appear on an AssertR.

In other words, the AssertL-only dispatch in visit_node is the correct
detection strategy and should stay. The defect is entirely in handle_debug's
else branch: it treats "CMR absent from debug_symbols" as inherently
anomalous when, for AssertL nodes, that is the overwhelmingly common case --
the normal, expected shape of both the unwrap* sentinel and any pruned match
branch, not a sign of corruption. It should be handled the same as the existing
"found, but not a Debug variant" case (src/tracker.rs:256-258): return
silently, no warning.

The one residual argument for keeping the warning is that it would fire if a
program were executed against a stale or mismatched DebugSymbols table. But
that situation is indistinguishable from the normal cases above, so the check
has no discriminating power and should go.