MARK_DEBUG and nameHint

[bgamari]

Currently it's quite unclear how best to observe internal signal of a design's HDL (e.g. via logic analyser core or simulation). For instance, consider a simple design:

blink :: forall dom. HiddenClockResetEnable dom => Signal dom Bool
blink =                                                                                                                                                                                                                                                
    let n :: Signal dom (BitVector 32)                                                                                                                                                                                                                 
        n = register 0 (n+1)                                                                                                                                                                                                              
    in even <$> n                                                                                                                                                                                                                                      

In order to observe the value of n, ideally one would want a function

debug :: SSymbol name -> Signal dom a -> Signal dom a

such that one could write:

    let n = debug (SSymbol @"n") $ register 0 (n+1)                                                                                                                                                                                                              
    in even <$> n                                                                                                                                                                                                                                      

However, it's not at all clear how to implement debug with the tools currently provided by Clash.

Clash.Annotations.SynthesisAttributes.markDebug would appear to be part of the answer since it ensures that the signal is visible after synthesis; however, the name given to the signal by Clash is almost always unhelpful. To fix this, one might think to use nameHint, e.g.

debug :: SSymbol name -> Signal dom a -> Signal dom a                                                                                                                                                                                                  
debug name = nameHint name . markDebug                                                                                                                                                                                                                 

However, this labels the wrong signal:

  (* keep = 1, mark_debug = 1, noprune, preserve *) wire [31:0] c$n_app_arg_1;                                                                                                                                                                         
  assign c$n_app_arg_1 = c$n_app_arg_0;                                                                                                                                                                                                                

If one inverts the nameHint and markDebug one finds that sometimes the output is sensible:

  (* keep = 1, mark_debug = 1, noprune, preserve *) wire [31:0] n_1;                                                                                                                                                                                   
  assign n_1 = n_0;                                                                                                                                                                                                                                    

However, in non-trivial cases one still gets an unexpected name. Perhaps there is a combination of inlining properties to make this more robust? Has anyone else encountered this? It feels like this would be a valuable addition to clash-prelude.