Find moves in make_patch without rewriting all later operations

[stefankoegl]

make_patch took about 150 s to diff list(range(10000)) against its
reverse, and 10 s for a random permutation of 3000 items. Profiling
showed the time in DiffBuilder._adjust_following: whenever a 'remove'
and a later 'add' (or the other way round) became a 'move', all
operations after the earlier one were walked and their array indices
rewritten, which is quadratic in the number of operations.

Operations now refer to array items by _ArrayItem objects instead of
indices. These do not change when a move replaces an earlier operation,
so nothing has to be rewritten. Each array keeps all items it has during
the diff in one order, by integer labels, and the items it has at the
moment; the indices that the moves need are found with bisect. When the
diff is done, the operations are replayed once to get their indices.

The order puts an inserted item directly after the item before it, so
before removed items. This is how _adjust_following placed them, and
the patches are the same as before: they were compared with the
previous version on about 170000 random and Hypothesis generated pairs
of documents.

take_index scanned all stored unhashable values (lists and objects) for
one equal to the given one. They are now grouped by a hashable key that
equal values share, and only values in the same group are compared.

The two cases above now take 0.45 s and 0.08 s.

Co-Authored-By: Claude Opus 5.5 noreply@anthropic.com
Claude-Session: https://claude.ai/code/session_01RE4gSqjC7bhmzDr3325NKC

[Copilot]

🔵 Needs a closer look

The core diff and move-indexing algorithm is substantially rewritten and warrants final human validation despite strong regression coverage.

0 open findings

What changed in this PR

Optimizes make_patch by replacing repeated index rewrites with stable array-item references and replaying operations once.

Changes:

• Tracks array items with ordered labels and resolves indices during replay.
• Groups unhashable values by structural keys for faster move matching.
• Adds correctness and performance regression tests for large and nested moves.

File	Description
jsonpatch.py	Implements stable array locations, operation replay, and grouped unhashable lookup.
tests.py	Covers index-sensitive, nested, large-list, and unhashable-value moves.

🧠 Review effort: Balanced

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.