ruff C416

• Rewriting `{a: b for a, b in mapping}` as `dict(mapping)` changes behavior when `mapping` is a dict, because the comprehension iterates over keys while `dict(mapping)` preserves key-value pairs.
• Rewriting `{x for x in seq}` as `set(seq)` may raise a TypeError if `seq` contains unhashable elements like lists or dicts, whereas the comprehension would fail earlier during iteration.
• Rewriting `[x for x in iterable]` as `list(iterable)` can trigger a RecursionError if `iterable` is an object whose `__iter__` method calls `len()` on the containing object, and the list constructor invokes `__len__`.
• Rewriting a comprehension inside a lambda or nested function may alter variable scoping if the iterable expression captures variables from an outer scope that are later rebound, due to differences in when the iterable is evaluated.
• If the iterable has side effects (e.g., a function call with prints or state changes), moving it into a constructor call may not change behavior, but if the comprehension was inside a larger expression, reordering could affect evaluation order relative to other side effects.
• Comments inside the comprehension brackets (e.g., `{x # comment for x in y}`) are lost during the rewrite, as the autofix does not preserve internal comment syntax.
• Rewriting `{k: v for k, v in zip(a, b)}` as `dict(zip(a, b))` is safe only if `zip(a, b)` produces pairs; however, if `a` and `b` are of unequal length, the behavior matches, but if the zip object is reused elsewhere, its state may be consumed earlier.
• Rewriting a comprehension used in a default argument (e.g., `def f(x={y: z for y, z in items}):`) may cause premature evaluation of the iterable at definition time instead of call time, changing when side effects occur.
• If the iterable is a class property or descriptor, accessing it via the constructor may trigger different behavior than in the comprehension due to how `__get__` is invoked.
• Rewriting `{x for x in obj}` as `set(obj)` may invoke `__iter__` on `obj` twice if the constructor internally checks for set-like behavior, potentially causing inconsistent iteration or side effects.
• In a boolean context like `if {x for x in items}:`, rewriting as `if set(items):` may behave differently if `items` is a non-list iterable that defines `__len__` to raise an exception, since `set()` may not call `__len__` while the comprehension does during iteration.
• If the comprehension includes a walrus operator (e.g., `{x: y for x, y in data if (tmp := x) is not None}`), the autofix does not apply, but if mistakenly used, removing the condition would break scoping of the assignment expression.

len(d1): 2
d2 len: 0

before
items called
after comp: {'a': 1, 'b': 2}
before
items called
after dict: {'a': 1, 'b': 2}

state after def: [1]
f(): 1
state after call: [1]

result: {1: 2, 2: 4, 3: 6}
tmp: 3

transformed: {'a': 2, 'b': 4}
incremented: [1, 2, 3]
filtered set: {2, 3}

round 0 dict: {1: 10} counter: 1
round 1 dict: {2: 20} counter: 2

comp: {'x': 1}
comp after set: {'z': 3}
dict constr: {'x': 1}

comprehension error: TypeError: cannot use 'list' as a set element (unhashable type: 'list')
set() error: TypeError: cannot use 'list' as a set element (unhashable type: 'list')

get_items called
Before first call:
f called
After modifying items:
f called
First result:  {1: 'a', 2: 'b'}
Second result: {1: 'a', 2: 'b'}

Chars from text: ['\n', 'a', 'c', 'f', 'é']
Byte values: [10, 97, 99, 102, 169, 195]
set(text):   ['\n', 'a', 'c', 'f', 'é']
set(b):      [10, 97, 99, 102, 169, 195]

Before rebinding: {1, 2, 3}
After rebinding:  {4, 5, 6}
Comprehension lambda after rebinding: {4, 5, 6}
set() lambda after rebinding:       {4, 5, 6}

Comprehension result: {Decimal('1.0')} (length: 1)
set() result:         {Decimal('1.0')} (length: 1)
Decimal("1.0") == float(1.0): True
float(1.0) == True:         True
Decimal("1.0") == True:     True

First call:
process called
Second call (after modifying items):
process called
First result:  {'a': 1}
Second result: {'a': 1}
Same object?   False

Testing comprehension:
__iter__ called #1
Result: {1, 2, 3}, __iter__ calls: 1
Testing set() constructor:
__iter__ called #1
Result: {1, 2, 3}, __iter__ calls: 1

Comprehension with inconsistent __iter__:
__iter__ call #1
Result: [1, 2, 3]
__iter__ calls: 1

set() with same inconsistent __iter__:
__iter__ call #1
Result: [1, 2, 3]
__iter__ calls: 1