Fix XML writer: write userAttr on correct per-element scopes

Previously write_user_attrs() was called on coverage container elements
(toggleCoverage, blockCoverage, branchCoverage, conditionCoverage,
fsmCoverage, assertionCoverage) with the parent INSTANCE scope, which:
  1. Duplicated INSTANCE attrs into every coverage container
  2. Lost all per-element attrs (TOGGLE/BLOCK/BRANCH/COND/etc. scopes)

Deep audit of merged_ncdb.cdb showed 201,883 user attributes in the
NCDB model but only 422 in the generated XML — a 99.8% loss.

Fix: remove container-level write_user_attrs(container, INSTANCE_scope)
calls and instead call write_user_attrs on each individual coverage
element using its own scope:
  - toggleObject ← TOGGLE scope attrs (174,516)
  - statement in blockCoverage ← BLOCK scope attrs (21,441)
  - statement in branchCoverage ← BRANCH scope attrs (3,219)
  - expr in conditionCoverage ← COND scope attrs (2,415)
  - coverpoint ← COVERPOINT scope attrs (59)
  - fsm ← FSM scope attrs (16)
  - assertion ← ASSERT scope attrs (27)
  - cgInstance ← COVERINSTANCE scope attrs (22)
  - covergroupCoverage ← COVERGROUP scope attrs (11)

After fix: 201,819 userAttr in XML (64 from FSM_STATES/FSM_TRANS
container scopes are intentionally unwritten — they have no
corresponding element in the UCIS XML schema).

XML still validates against ucis.xsd with zero errors.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mballance

src/ucis/xml/xml_writer.py

@@ -250,7 +250,7 @@ def write_toggle_coverage(self, inst_elem, scope):
                     bin_elem = self.mkElem(toggle_elem, "bin")
                     contents_elem = self.mkElem(bin_elem, "contents")
                     contents_elem.set("coverageCount", str(bin_item.getCoverData().data))
-        self.write_user_attrs(tc_elem, scope)
+            self.write_user_attrs(to_elem, toggle_scope)
 
     def write_block_coverage(self, inst_elem, scope):
         block_scopes = list(scope.scopes(ScopeTypeT.BLOCK))
@@ -266,7 +266,7 @@ def write_block_coverage(self, inst_elem, scope):
                 bin_elem = self.mkElem(stmt_elem, "bin")
                 contents_elem = self.mkElem(bin_elem, "contents")
                 contents_elem.set("coverageCount", str(stmt.getCoverData().data))
-        self.write_user_attrs(bc_elem, scope)
+                self.write_user_attrs(stmt_elem, block_scope)
 
     def write_branch_coverage(self, inst_elem, scope):
         branch_scopes = list(scope.scopes(ScopeTypeT.BRANCH))
@@ -286,7 +286,7 @@ def write_branch_coverage(self, inst_elem, scope):
                 bb_elem.set("alias", arm.getName())  # use alias to preserve name
                 contents_elem = self.mkElem(bb_elem, "contents")
                 contents_elem.set("coverageCount", str(arm.getCoverData().data))
-        self.write_user_attrs(bc_elem, scope)
+            self.write_user_attrs(stmt_elem, branch_scope)
 
     def write_fsm_coverage(self, inst_elem, scope):
         fsm_scopes = list(scope.scopes(ScopeTypeT.FSM))
@@ -323,7 +323,7 @@ def write_fsm_coverage(self, inst_elem, scope):
                 tb_elem = self.mkElem(trans_elem, "transitionBin")
                 contents = self.mkElem(tb_elem, "contents")
                 contents.set("coverageCount", str(bin_item.getCoverData().data))
-        self.write_user_attrs(fc_elem, scope)
+            self.write_user_attrs(fsm_elem, fsm_scope)
 
     def write_assertion_coverage(self, inst_elem, scope):
         assert_scopes = (list(scope.scopes(ScopeTypeT.ASSERT))
@@ -360,7 +360,7 @@ def write_assertion_coverage(self, inst_elem, scope):
                     contents = self.mkElem(bin_elem, "contents")
                     contents.set("coverageCount",
                                  str(sum(b.getCoverData().data for b in bins)))
-        self.write_user_attrs(ac_elem, scope)
+            self.write_user_attrs(asrt_elem, assert_scope)
 
     def write_condition_coverage(self, inst_elem, scope):
         cond_scopes = list(scope.scopes(ScopeTypeT.COND))
@@ -398,7 +398,7 @@ def write_condition_coverage(self, inst_elem, scope):
                 bin_elem.set("alias", bin_item.getName())
                 contents_elem = self.mkElem(bin_elem, "contents")
                 contents_elem.set("coverageCount", str(bin_item.getCoverData().data))
-        self.write_user_attrs(cc_elem, scope)
+            self.write_user_attrs(expr_elem, cond_scope)
 
     def write_covergroups(self, inst, scope):
         for cg in scope.scopes(ScopeTypeT.COVERGROUP):
@@ -417,6 +417,7 @@ def write_covergroups(self, inst, scope):
                 while cg_inst is not None:
                     self.write_coverinstance(cgElem, cg.getScopeName(), cg_inst)
                     cg_inst = next(inst_it, None)
+            self.write_user_attrs(cgElem, cg)
 
     def write_coverinstance(self, cgElem, cgName, cg : Covergroup):
         cgInstElem = self.mkElem(cgElem, "cgInstance")
@@ -446,6 +447,7 @@ def write_coverinstance(self, cgElem, cgName, cg : Covergroup):
 
         for cr in cg.scopes(ScopeTypeT.CROSS):
             self.write_cross(cgInstElem, cr)
+        self.write_user_attrs(cgInstElem, cg)
 
     def write_coverpoint(self, cgInstElem, cp : Coverpoint):
         cpElem = self.mkElem(cgInstElem, "coverpoint")
@@ -466,6 +468,7 @@ def write_coverpoint(self, cgInstElem, cp : Coverpoint):
             for cs in cp.scopes(_BINSCOPE_MASK):
                 bins.extend(cs.coverItems(_BIN_MASK))
         self.write_coverpoint_bins(cpElem, iter(bins))
+        self.write_user_attrs(cpElem, cp)
 
     def write_coverpoint_bins(self, cpElem, coveritems : Iterator[CoverIndex]):
         # TODO: should probably organize bins into a structure that fits more nicely into the interchage format