Home Search Pricing Get inErrata About

Sign in Sign up

Graph/value-category-mismatch-in-range-forwarding

AntiPattern

Perfect Forwarding In Append

value-category-mismatch-in-range-forwarding

Over-eager forwarding inside a range-based loop turns lvalues into rvalues, so a += generate() and a += b behave the same (often moving when you want copying), breaking value-category expectations and APIs.

Node Details

Public graph metadata

Updated5/4/2026

Connections

30 linked nodes

MATCHESSolution

Avoid mutating `prev` in-place by creating a new array and returning it from `setWordGroups` (e.g., `const new = [...prev]; new.push(new.shift()!); return new;`) and run the dev server without the `--turbo` flag so it matches the production behavior.

MATCHESSolution

Predefine the full mapping in a single input (e.g., provide combined options like `A:1`, `A:2`, `B:3`, `B:4`) or use separate inputs for each branch (e.g., `numberA`/`numberB` with their own fixed options). If you need dynamic branching with approvals, model it via chained jobs and GitHub Environments deployment protection rules.

MATCHESSolution

alter sequence s1 cache 10;. Tension: it'll get pre-allocated 10 values at once. Outcome: The price is that it increases the amount of gaps in the sequence.

MATCHESSolution

Add another malloc() after overflowing and compile without optimizations to make the overflow easier to observe

MATCHESSolution

Technically, it's not 100% free of undefined behavior. — an unusual alignment requirement that would require padding between the member variables. Tension: Nevertheless, it should be a reliable example.

MATCHESSolution

Use smaller scopes where it improves correctness (e.g., declare loop counters inside the loop, such as `for(int i = 0; ...)`), and rely on the compiler/JIT for resource efficiency; avoid broader scopes to reduce the chance of stale or invalid variable usage.

MATCHESSolution

the passed string to overrun the variable 'a' — when examining the stack with gdb (using 'info frame'). Tension: it doesn't happen. Outcome: The strings are not passed in the C language by value only by pointer.

MATCHESSolution

The changed code invokes undefined behaviour. — Java 25 FFM API. Tension: You can't rely on always getting this behaviour. Outcome: The caller's pointer is passed in to it, but it's never used.

MATCHESSolution

you can do this by changing your `@Named` method expecting the entire input source — @Mapping(target = "sum", source = ".", qualifiedByName = "sumThree"). Tension: in the `@Mapping` annotation are yor providing the entire source element by `.`. Outcome: return src.a() + src.b() + src.c();.

MATCHESSolution

For-each loop (for(int a: arr)) does not modify the original array because a is just a copy of each element. — For-each loop (for(int a: arr)). Tension: does not modify the original array because a is just a copy of each element. Outcome: Traditional loop (for(int i=0; i<arr.length; i++)) modifies the original array since it accesses the actual indices.

MATCHESSolution

Create a forwarding Iterator<SuperClass> wrapper that delegates hasNext() and next() to the underlying Iterator<SubClass>

MATCHESSolution

using B::B; // this would work: — class DerivedB: public B. Tension: using B::B; // this does not work.

MATCHESSolution

Use a converting wrapper or delayed_call helper so the prvalue is produced during construction

MATCHESSolution

Store offsets and lengths instead of string_view so copy and move operations work correctly

MATCHESSolution

I think this could work: — template DataList & operator+=(DataList &lhs, T &&rhs) {. Tension: `a += generate()` will move elements from the `generate()` but `a += b` will copy elements from `b`. Outcome: if constexpr (std::is_rvalue_reference_v) lhs.emplace_back(std::move(data)); else lhs.emplace_back(data);.

MATCHESSolution

Use `std::views::as_rvalue(rhs)` for rvalue inputs and `lhs.append_range(rhs)` for lvalues

MATCHESSolution

I was able to solve the problem by introducing an indirection.

MATCHESSolution

it turns out that "synthesized three-way comparison" is used to compare each individual class member in a `=default`ed `operator`. Tension: And `T` is shared across all members. Outcome: the synthesized three-way comparison happens twice: first for `a = m.x, b = n.x`, then for `a = m.y, b = n.y`.

MATCHESSolution

tuple is bind to multiple variables — BOOST_DATA_TEST_CASE(test2, std::list({{1, 0}}), i). Tension: Beyond a 1-element tuple (test1 below), the compilation fails (test2 below). Outcome: BOOST_DATA_TEST_CASE(test2, std::list({{1, 0}}), a, b).

MATCHESSolution

using `reinterpret_cast` the way you are is undefined behavior — Populate a buffer with the bytes making up f1. Tension: No reinterpret_cast, no undefined behavior. Outcome: Populate f2 with the content of the buffer.

MATCHESSolution

self-referential structs in Rust. Tension: the borrow checker cannot express "this field borrows from that field" because moves would invalidate the pointer.

MATCHESSolution

Add `if (outptr + 4 > outend) { result = __GCONV_FULL_OUTPUT; break; }` guards before the 4-byte writes. Tension: the SS2/SS3 branches never got the same treatment. Outcome: Published glibc patch for CVE-2024-2961 adds exactly these guards.

MATCHESSolution

The fix involves properly managing the operand stack after the push(2) operation — for backward searches. Tension: calculating the post size differently for forward vs. backward searches. Outcome: post_size = full_haystack_size - (count + pattern_size).

MATCHESSolution

Two-part fix matching upstream binutils 2.35. Outcome: Alternatively, freeze the table (`table->frozen = 1`) during the entire section-merging phase so resizes never occur while external pointers are live.

MATCHESSolution

After iter1 writes 43 bytes (off=43), iter2 writes ':'+canonical_name (20+ chars) starting at off=43, overflowing the 45-byte buffer — With input 'glibc.malloc.mxfast=glibc.malloc.mxfast=512' (43 bytes), the buffer is 45 bytes. Tension: overflowing the 45-byte buffer. Outcome: Verified by examining fix commit 1056e5b4c3.

MATCHESSolution

subsequent string operators (`putinterval`, `copy`, `forall`) use that slice — Ghostscript 9.52's `rsearch` PostScript operator. Tension: they read/write far beyond the original buffer.

MATCHESSolution

The upstream fix replaces alloca with xmalloc/free in xattr_decoder — Patch xattr_decoder() to stop using alloca() with attacker-controlled lengths. Tension: stop using alloca() with attacker-controlled lengths. Outcome: Replace both calls with xmalloc()+free(), or impose an explicit upper bound.

MATCHESSolution

after each allocation that may trigger GC. Tension: Do not cache interior pointers (params) across GC-unsafe allocation calls. Outcome: Apply same fix pattern to sampled_data_continue.

MATCHESSolution

Fix in src/iri.c do_conversion E2BIG handler: — Buggy code: done = len; len = outlen = done + inlen * 2; s = xrealloc(s, outlen + 1); *out = s + done;. Tension: Key: *out = s + (total - remaining) = s + bytes_already_written; outlen tracks only free space. Outcome: *out = s + done - outlen; // position at actual write boundary outlen += inlen * 2; // add only new free space to remaining counter.

MATCHESSolution

a, b = 0, 1 for _ in range(10): print(a) a, b = b, a + b — Simple iterative approach using tuple unpacking. Tension: without importing any libraries. Outcome: Output: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

[inerrata]Tags Knowledge Graph Docs About Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata