test: print rebuild target names instead of counts

Per rgrinberg review on ocaml#14310: replace the [length]-based jq
pipeline with the idiomatic [targetsMatchingFilter] pattern used
in sibling tests (e.g. alias-reexport.t). The recorded output now
shows the actual target paths under [_build/default/consumer/]
that are rebuilt when each of A1/A2/A3 is edited, rather than a
bare count.

This also unifies the three blocks: A1, A3, and A2 all use the
same pipeline. Once ocaml#14116's per-module filter lands, the A1/A3
blocks promote to [], while A2 keeps the c.cmi/c.cmo/c.cmt list.

Signed-off-by: Robin Bate Boerop <me@robinbb.com>

Author: robinbb

test/blackbox-tests/test-cases/per-module-lib-deps/unwrapped-tight-deps.t

@@ -1,112 +1,141 @@
-Baseline: consumer-module rebuild count when individual modules of
-an unwrapped dependency library change.
+Baseline: consumer-module rebuild targets when individual modules
+of an unwrapped dependency library change.
 
-This is an observational test. It records the number of rebuild
-targets for a single consumer module C when each of three entry
-modules (A1, A2, A3) of the dependency library [base] has its
-interface edited. C references only A2.
+This is an observational test. It records the rebuild targets for
+the consumer module [consumer] when each of three entry modules of
+the dependency library [dep_lib] has its interface edited.
+[consumer] references only [Referenced_dep] from [dep_lib];
+[Unread_dep_a] and [Unread_dep_b] are present but unreferenced.
 
-On current main, editing any one of A1/A2/A3 causes C to rebuild
+On current main, editing any of the three rebuilds [consumer]
 because library-level dependency filtering (and, within that,
 per-module tightening) is not yet in place: the consumer is
 conservatively rebuilt whenever any entry module's cmi changes.
 Work on https://github.com/ocaml/dune/issues/4572 is expected to
-tighten this, at which point editing A1 or A3 leaves C untouched
-and the emitted counts are promoted.
+tighten this, at which point editing [Unread_dep_a] or
+[Unread_dep_b] leaves [consumer] untouched and the emitted target
+list becomes empty.
 
 See: https://github.com/ocaml/dune/issues/4572
 
   $ cat > dune-project <<EOF
-  > (lang dune 3.22)
+  > (lang dune 3.23)
   > EOF
 
-base is an unwrapped library with three entry modules, each with an
-explicit interface so signature changes propagate through .cmi files:
+[dep_lib] is an unwrapped library with three entry modules, each
+with an explicit interface so signature changes propagate through
+.cmi files:
 
-  $ mkdir base
-  $ cat > base/dune <<EOF
-  > (library (name base) (wrapped false))
+  $ mkdir dep_lib
+  $ cat > dep_lib/dune <<EOF
+  > (library (name dep_lib) (wrapped false))
   > EOF
-  $ cat > base/a1.ml <<EOF
+  $ cat > dep_lib/unread_dep_a.ml <<EOF
   > let v = 1
   > EOF
-  $ cat > base/a1.mli <<EOF
+  $ cat > dep_lib/unread_dep_a.mli <<EOF
   > val v : int
   > EOF
-  $ cat > base/a2.ml <<EOF
+  $ cat > dep_lib/referenced_dep.ml <<EOF
   > let v = 2
   > EOF
-  $ cat > base/a2.mli <<EOF
+  $ cat > dep_lib/referenced_dep.mli <<EOF
   > val v : int
   > EOF
-  $ cat > base/a3.ml <<EOF
+  $ cat > dep_lib/unread_dep_b.ml <<EOF
   > let v = 3
   > EOF
-  $ cat > base/a3.mli <<EOF
+  $ cat > dep_lib/unread_dep_b.mli <<EOF
   > val v : int
   > EOF
 
-consumer has two modules. The module of interest, [c.ml], references
-only [A2] from [base]. A second, unused module [d.ml] is present only
-to keep [consumer] a multi-module stanza: dune skips ocamldep for
-single-module stanzas with no library deps as an optimisation, and
-the per-module-lib-deps filter depends on ocamldep output. Including
-[d.ml] isolates this test from the skip-ocamldep optimisation so the
-rebuild count for [c] reflects only the per-module filter's work:
+[consumer_lib] has two modules. The module of interest, [consumer],
+references only [Referenced_dep] from [dep_lib]. A second, unused
+module [filler] is present only to keep [consumer_lib] a multi-
+module stanza: dune skips ocamldep for single-module stanzas with
+no library deps as an optimisation, and the per-module-lib-deps
+filter depends on ocamldep output. Including [filler] isolates
+this test from the skip-ocamldep optimisation so the rebuild
+targets for [consumer] reflect only the per-module filter's work:
 
-  $ mkdir consumer
-  $ cat > consumer/dune <<EOF
-  > (library (name consumer) (wrapped false) (libraries base))
+  $ mkdir consumer_lib
+  $ cat > consumer_lib/dune <<EOF
+  > (library (name consumer_lib) (wrapped false) (libraries dep_lib))
   > EOF
-  $ cat > consumer/c.ml <<EOF
-  > let w = A2.v
+  $ cat > consumer_lib/consumer.ml <<EOF
+  > let w = Referenced_dep.v
   > EOF
-  $ cat > consumer/d.ml <<EOF
+  $ cat > consumer_lib/filler.ml <<EOF
   > let _ = ()
   > EOF
 
   $ dune build @check
 
-Edit A1's interface — a module C does not reference — and record
-the rebuild-target count for C:
+Edit [Unread_dep_a]'s interface — a module [consumer] does not
+reference — and record the rebuild targets for [consumer]:
 
-  $ cat > base/a1.mli <<EOF
+  $ cat > dep_lib/unread_dep_a.mli <<EOF
   > val v : int
   > val extra : unit -> int
   > EOF
-  $ cat > base/a1.ml <<EOF
+  $ cat > dep_lib/unread_dep_a.ml <<EOF
   > let v = 1
   > let extra () = 7
   > EOF
   $ dune build @check
-  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer/\\.consumer\\.objs/byte/c\\."))] | length'
-  1
+  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer_lib/\\.consumer_lib\\.objs/byte/consumer\\."))]'
+  [
+    {
+      "target_files": [
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmi",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmo",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmt"
+      ]
+    }
+  ]
 
-Same for A3:
+Same for [Unread_dep_b]:
 
-  $ cat > base/a3.mli <<EOF
+  $ cat > dep_lib/unread_dep_b.mli <<EOF
   > val v : int
   > val other : string
   > EOF
-  $ cat > base/a3.ml <<EOF
+  $ cat > dep_lib/unread_dep_b.ml <<EOF
   > let v = 3
   > let other = "hi"
   > EOF
   $ dune build @check
-  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer/\\.consumer\\.objs/byte/c\\."))] | length'
-  1
+  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer_lib/\\.consumer_lib\\.objs/byte/consumer\\."))]'
+  [
+    {
+      "target_files": [
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmi",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmo",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmt"
+      ]
+    }
+  ]
 
-Edit A2's interface — the one module C does reference — and check
-that the count is positive (C must rebuild):
+Edit [Referenced_dep]'s interface — the one module [consumer] does
+reference — and record the rebuild targets ([consumer] must
+rebuild):
 
-  $ cat > base/a2.mli <<EOF
+  $ cat > dep_lib/referenced_dep.mli <<EOF
   > val v : int
   > val new_fn : int -> int
   > EOF
-  $ cat > base/a2.ml <<EOF
+  $ cat > dep_lib/referenced_dep.ml <<EOF
   > let v = 2
   > let new_fn x = x + 1
   > EOF
   $ dune build @check
-  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer/\\.consumer\\.objs/byte/c\\."))] | length > 0'
-  true
+  $ dune trace cat | jq -s 'include "dune"; [.[] | targetsMatchingFilter(test("consumer_lib/\\.consumer_lib\\.objs/byte/consumer\\."))]'
+  [
+    {
+      "target_files": [
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmi",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmo",
+        "_build/default/consumer_lib/.consumer_lib.objs/byte/consumer.cmt"
+      ]
+    }
+  ]