fix(UniTensor): eliminate overlapping memcpy in combineBonds

[IvanaGyro]

Problem

Fixes #1052.

BlockUniTensorTest.CombineBondForceDoesNotRewriteUserHeldBond aborts under
ASan with memcpy-param-overlap. The issue's own stack trace points at
vec_map (src/utils/vec_map.cpp) as the allocation site of the corrupted
buffer, but that is only where ASan's shadow memory was allocated — vec_map
itself contains no memcpy at all and is not the bug.

Running the test directly (rather than relying on the issue's captured trace)
gives the real fault stack:

==ERROR: AddressSanitizer: memcpy-param-overlap
    #1 cytnx::BlockUniTensor::combineBonds(...)  src/BlockUniTensor.cpp:1996
    #2 cytnx::BlockUniTensor::combineBond(...)   src/BlockUniTensor.cpp:2027
    #3 cytnx::UniTensor::combineBond_(...)       include/UniTensor.hpp:4902

combineBonds has sites in three of the four UniTensor backends that
left-shift a std::vector into itself via memcpy, which is undefined
behavior whenever the shift distance is smaller than the region being moved
(source and destination byte ranges overlap):

• BlockUniTensor::combineBonds (src/BlockUniTensor.cpp) — two sites:
  1. _inner_to_outer_idx tail shift — drops indicators.size()-1
     elements starting at idor+1 and shifts the tail left. It overlaps
     whenever the remaining tail is at least twice the shift distance; the
     existing 2-bond regression test already hits this exactly.
  2. cb_stride shift-by-one — latent (only overlaps once 3+ bonds are
     combined at once, which no existing test exercised), but the same UB
     class in the same function, with a commented-out backward loop sitting
     next to it as an abandoned alternative.
• BlockFermionicUniTensor::combineBonds (src/BlockFermionicUniTensor.cpp)
  has the identical two sites (its own comment marks it "a copy from
  BlockUniTensor").
• DenseUniTensor::combineBonds (src/DenseUniTensor.cpp) has a
  structurally identical new_shape tail shift — same overlap condition,
  same variable names (idor, indicators). Combining the first two of
  four adjacent bonds (idor=0, indicators.size()=2) reproduces the exact
  same overlap geometry as the BlockUniTensor case.

I grepped all four combineBonds implementations for memcpy and confirmed
these are the only overlapping sites; Tensor::combineBonds (dense array
reshape only, no bond bookkeeping) uses no such shift.

Fix

Every site is replaced with well-defined standard-library equivalents that
perform the exact same left-shift, across BlockUniTensor.cpp,
BlockFermionicUniTensor.cpp, and DenseUniTensor.cpp:

• cb_stride shift → std::copy(cb_stride.begin() + 1, cb_stride.end(), cb_stride.begin()), well-defined for a left-shift since std::copy
  iterates forward, writing to already-read positions.
• _inner_to_outer_idx / new_shape tail shift → vector::erase(begin+idor+1, begin+idor+indicators.size()), which removes exactly the same elements
  and leaves the vector at the correct final length, so the trailing
  resize(this->rank()) is no longer needed.

This is a memory-safety-only fix. Every replacement computes the exact
same result the memcpy calls intended; combineBonds' numerical output is
unchanged across all three backends, only the undefined behavior is removed.

BlockFermionicUniTensor::combineBonds(vector, force) is fixed
for source hygiene/consistency with BlockUniTensor, but is currently
unreachable through any public API path — it starts with an
unconditional cytnx_error_msg(true, "...not implemented yet.") behind a
TODOfermion: signflips need to be included!!! comment. Lifting that guard
to exercise the fix live would be a functional change to fermionic
sign-flip handling, out of scope here; a new test
(CombineBondsStillUnimplemented) pins the current throw so this scope
statement stays true.

Testing

New tests, each verified to fail pre-fix and pass post-fix:

• BlockUniTensorTest.CombineBondsThreeBondsPreservesDataAndDimension — a
  3-bond combine that exercises the cb_stride site. Verified pre-fix: aborts
  under ASan at BlockUniTensor.cpp:1964 with memcpy-param-overlap. Checks
  the combined bond's dimension against the independently computed product of
  the three input dimensions, and checks block values against the pre-combine
  block reshaped by hand (row-major merge of its first three axes, matching
  how Bond_impl::force_combineBond_ orders the combined qnum index) —
  independent of the bookkeeping this PR touches.
• BlockFermionicUniTensorTest.CombineBondsStillUnimplemented — documents
  the current unreachability (see above).
• DenseUniTensorTest.CombineBondsFourBondsPreservesDataAndShape — a 4-bond
  dense tensor combining the first two adjacent bonds. Verified pre-fix:
  aborts under ASan at DenseUniTensor.cpp:855 with memcpy-param-overlap
  (same failure signature as the BlockUniTensor case). Checks the combined
  shape and values against an independently computed reshape of the original
  block, not just absence of a crash.
• The pre-existing BlockUniTensorTest.CombineBondForceDoesNotRewriteUserHeldBond
  re-confirmed pre-fix: aborts under ASan at BlockUniTensor.cpp:1996 with
  memcpy-param-overlap; passes post-fix.

Local results, both required CPU debug presets:

Preset	Suite	Result
debug-openblas-cpu	ctest (test_main)	1771/1771 passed
debug-mkl-cpu	ctest (test_main)	1805/1805 passed

No GPU/CUDA code touched (no #ifdef UNI_GPU, no src/backend/linalg_internal_gpu/),
so the CUDA compile-check gate does not apply. No cytnx/, pybind/, or
pytests/ changes, so pytest pytests/ does not apply.

Opened as a draft while the fix scope (BlockUniTensor +
BlockFermionicUniTensor + DenseUniTensor) gets a look.

[gemini-code-assist]

Code Review

This pull request replaces unsafe memcpy operations with standard C++ library functions (std::copy and std::vector::erase) in BlockFermionicUniTensor.cpp and BlockUniTensor.cpp to avoid potential undefined behavior during overlapping memory copies. It also adds corresponding unit tests to verify that combining three bonds preserves data and dimensions correctly in BlockUniTensor, and confirms that the unimplemented combineBond_ method in BlockFermionicUniTensor still throws an error as expected. There are no review comments to address.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 60.52%. Comparing base (6600059) to head (ebffa0a).
⚠️ Report is 6 commits behind head on master.

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #1054      +/-   ##
==========================================
+ Coverage   60.38%   60.52%   +0.14%     
==========================================
  Files         229      229              
  Lines       31866    31866              
  Branches       71       71              
==========================================
+ Hits        19241    19286      +45     
+ Misses      12604    12559      -45     
  Partials       21       21              

Flag	Coverage Δ
cpp	60.47% <100.00%> (+0.14%)	⬆️
python	64.13% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Components	Coverage Δ
C++ backend	58.07% <100.00%> (+0.03%)	⬆️
Python bindings	75.01% <ø> (+0.75%)	⬆️
Python package	64.13% <ø> (ø)

Files with missing lines	Coverage Δ
src/BlockFermionicUniTensor.cpp	65.67% <ø> (+0.84%)	⬆️
src/BlockUniTensor.cpp	75.26% <100.00%> (-0.10%)	⬇️
src/DenseUniTensor.cpp	86.77% <100.00%> (-0.05%)	⬇️

... and 5 files with indirect coverage changes

---

Continue to review full report in Codecov by Harness.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 6600059...ebffa0a. Read the comment docs.

🚀 New features to boost your workflow:

• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[yingjerkao]

LGTM