Simplify text diff and hierarchy reports

Use signed cell rows and keep whole-cell contents out of the text diff. Group reference changes, fold redundant terminal edges into the cell list, and inline one-off layer names. Count identical unmatched objects while retaining occurrence-based display limits.
This commit is contained in:
Jan Petykiewicz 2026-11-18 20:12:42 -08:00
commit ed1e0595bc
2 changed files with 775 additions and 226 deletions

View file

@ -112,7 +112,7 @@ fn object_xy(object: &ObjectChange) -> &[u8] {
.map_or(&[], |field| field.data.as_slice())
}
pub(super) fn write_unmatched(out: &mut String, sign: &str, object: &ObjectChange) {
pub(super) fn write_unmatched(out: &mut String, object: &ObjectChange) {
if object.kind == RTAG_PATH
&& let Some([xmin, ymin, xmax, ymax]) = object.bounds
{
@ -124,13 +124,13 @@ pub(super) fn write_unmatched(out: &mut String, sign: &str, object: &ObjectChang
.map_or_else(|| "absent".to_string(), |width| format!("{width} dbu"));
writeln!(
out,
" {sign} {heading} · width {width} · {vertices} vertices · bounds ({xmin}, {ymin}) to ({xmax}, {ymax}) dbu"
"{heading} · width {width} · {vertices} vertices · bounds ({xmin}, {ymin}) to ({xmax}, {ymax}) dbu"
)
.unwrap();
return;
}
}
writeln!(out, " {sign} {object}").unwrap();
writeln!(out, "{object}").unwrap();
}
fn vertex_count(xy: &[u8]) -> usize {
@ -217,12 +217,14 @@ impl PolygonChanges {
shapes.add(object, None);
}
pub fn write(&self, out: &mut String) {
pub fn write(&self, out: &mut String, layers: &mut LayerRows<'_>) {
for (layer, counts) in &self.0 {
out.push_str(" ");
layers.record(*layer, out.len());
if let Some((layer, datatype)) = layer {
write!(out, " {layer}/{datatype}: ").unwrap();
write!(out, "{layer}/{datatype}: ").unwrap();
} else {
out.push_str(" unknown layer: ");
out.push_str("unknown layer: ");
}
let mut separator = "";
for (action, shapes) in [
@ -261,41 +263,157 @@ pub(super) struct ReferenceCounts {
}
impl ReferenceCounts {
pub fn len(&self) -> usize {
self.singles + self.arrays
}
pub fn add(&mut self, object: &ObjectChange) {
if object.kind == RTAG_AREF {
self.arrays += 1;
if let Some([columns, rows]) = object.counts {
self.placements += u128::from(columns) * u128::from(rows);
}
} else {
self.singles += 1;
self.placements += 1;
}
self.placements += reference_placements(object);
}
pub fn write(&self, out: &mut String, sign: &str, target: &str) {
pub fn write(&self, out: &mut String, sign: &str, target: &str, first: &ObjectChange) {
if self.len() == 1 {
writeln!(out, " {sign} {first}").unwrap();
return;
}
write!(out, " {sign} ").unwrap();
self.write_counts(out, "");
write!(out, " to {}", cell_label(target)).unwrap();
self.write_placements(out);
out.push('\n');
}
fn len(&self) -> usize {
self.singles + self.arrays
}
pub fn write_change(&self, out: &mut String, target: &str, added: &Self) {
write!(out, " {} · ", cell_label(target)).unwrap();
self.write_counts(out, "-");
self.write_placements(out);
out.push_str(", ");
added.write_counts(out, "+");
added.write_placements(out);
out.push('\n');
}
fn write_counts(&self, out: &mut String, sign: &str) {
if self.singles > 0 {
let suffix = if self.singles == 1 { "" } else { "s" };
write!(out, "{} reference{suffix}", self.singles).unwrap();
write!(out, "{sign}{} ref{suffix}", self.singles).unwrap();
}
if self.arrays > 0 {
if self.singles > 0 {
out.push_str(", ");
}
let suffix = if self.arrays == 1 { "" } else { "s" };
write!(out, "{} array reference{suffix}", self.arrays).unwrap();
write!(out, "{sign}{} array ref{suffix}", self.arrays).unwrap();
}
write!(out, " to {target:?}").unwrap();
}
fn write_placements(&self, out: &mut String) {
if self.arrays > 0 {
let suffix = if self.placements == 1 { "" } else { "s" };
write!(out, " ({} placement{suffix})", self.placements).unwrap();
}
out.push('\n');
}
}
fn reference_placements(object: &ObjectChange) -> u128 {
match object.counts {
Some([columns, rows]) => u128::from(columns) * u128::from(rows),
None => 0,
}
}
#[derive(Default)]
pub(super) struct ShownReferences {
shown: usize,
total: usize,
removed: u128,
added: u128,
row_start: usize,
}
impl ShownReferences {
pub fn replacement(&mut self, old: &ObjectChange, new: &ObjectChange, row_start: usize) {
self.shown += 2;
self.removed += reference_placements(old);
self.added += reference_placements(new);
self.row_start = row_start;
}
pub fn unmatched(
&mut self,
removed: &ReferenceCounts,
added: &ReferenceCounts,
row_start: usize,
) {
self.shown += removed.len() + added.len();
self.removed += removed.placements;
self.added += added.placements;
self.row_start = row_start;
}
pub fn count_change(&mut self) {
self.total += 1;
}
pub fn complete(&self) -> bool {
self.shown == self.total
}
pub fn annotate(&self, text: &str, annotations: &mut Vec<(usize, String)>, old: u64, new: u64) {
if (u128::from(old), u128::from(new)) == (self.removed, self.added) {
return;
}
let at = self.row_start + text[self.row_start..].find('\n').unwrap();
let totals = if old == new {
let suffix = if new == 1 { "" } else { "s" };
format!(" · {new} total placement{suffix}")
} else {
format!(" · placements {old} -> {new}")
};
annotations.push((at, totals));
}
}
pub(super) struct LayerRows<'a> {
names: &'a BTreeMap<Layer, String>,
rows: BTreeMap<Layer, Option<usize>>,
}
impl<'a> LayerRows<'a> {
pub fn new(names: &'a BTreeMap<Layer, String>) -> Self {
Self {
names,
rows: BTreeMap::new(),
}
}
pub fn record(&mut self, layer: Option<Layer>, row_start: usize) {
if let Some(layer) = layer
&& self.names.contains_key(&layer)
{
self.rows
.entry(layer)
.and_modify(|first| *first = None)
.or_insert(Some(row_start));
}
}
pub fn finish(self, text: &str, annotations: &mut Vec<(usize, String)>, legend: &mut String) {
for (layer, first) in self.rows {
let name = &self.names[&layer];
if let Some(at) = first {
// Each recorded heading starts with the numeric layer/type and a colon.
let at = at + text[at..].find(':').unwrap();
annotations.push((at, format!(" ({})", cell_label(name))));
} else {
writeln!(legend, "{}/{}: name {name:?}", layer.0, layer.1).unwrap();
}
}
}
}

View file

@ -181,7 +181,7 @@ impl<'a> RevisionPair<'a> {
}
pub fn compare(self) -> Comparison {
Comparison::collect(&self.old, &self.new, &self.reused_cells, None)
Comparison::collect(&self.old, &self.new, &self.reused_cells, true)
}
pub fn compare_text(self) -> TextComparison {