ruff C404

• If the list comprehension uses a variable name that shadows an outer variable in the dict key or value expression, the dict comprehension may capture that variable differently due to its own local scope.
• If the iterable expression has side effects (e.g., a function call), moving it into the dict comprehension changes when those effects occur relative to other expressions in the same statement.
• If the list comprehension is nested inside another expression where the list's identity or mutability matters (e.g., passed to a function that modifies it), replacing it with a dict comprehension alters the object type and breaks expectations.
• If the comprehension contains a bare yield or yield-from, rewriting it as a dict comprehension changes it from a generator expression to a dict comprehension, altering execution timing and preventing lazy evaluation.
• If the original code relies on the list being built eagerly (e.g., for truthiness or length before iteration), the dict comprehension's lazy-like evaluation (though still eager in CPython) may not preserve intermediate state assumptions in rare edge cases involving __bool__ or __len__ overrides.
• If the list comprehension is part of a larger expression where operator precedence groups it unexpectedly (e.g., dict([(k, v) for k, v in items]) + {}), removing the list constructor could change parsing if parentheses are omitted incorrectly during rewrite.
• If the comprehension includes a tuple with more than two elements (e.g., [(k, v, w) for ...]), the rule should not fire, but if misapplied, the fix would raise a ValueError due to too many values to unpack in the dict comprehension.
• If the list comprehension is inside a lambda or nested function and uses a nonlocal variable, the dict comprehension's implicit scope may not preserve the same closure behavior, especially in Python 2 or under atypical execution contexts.
• Comments attached to the list brackets or for/clause tokens may be dropped during AST rewrite, even if the tool attempts preservation, due to formatting loss in the conversion process.
• If the iterable is the same variable being assigned to in the comprehension (e.g., dict([(x, x+1) for x in xs]) where xs is later reused), the rewrite is safe, but if the variable is deleted or reassigned mid-comprehension via del or side effect, the timing of observation differs.

iterable
{1: 1, 2: 4}

enter
exit: ['0', '1', 'done']
after

prop accessed
{'val': 10, 'prop': 10}

counter: 4 dict: {1: 2, 3: 4}

'str'

dict: {} len: 0

dict: {1: 1.75}

{1: 2}

list bool during: True
dict from list: {1: 1, 2: 2}
dict comp bool called: False

mutate list result: 3
final list: [(1, 2), (3, 4), (99, 99)]
list mutability test: 3
h is: <class 'dict'>
b before mutate: [((1, 2), (1, 2))] <class 'list'>
b after mutate: [((1, 2), (1, 2)), (99, 99)]
dict has no append

MAP defined as: dict
MAP contents: {'a': 'a', 'b': 'b'}

first call: {}
second call: {1: 2, 2: 4, 3: 6}
after mutate, p2(): {1: 2, 2: 4, 3: 6, 4: 8}