ruff FURB161

• If X is a function call with side effects, the rewrite changes evaluation timing but not frequency—still one call—but may affect interleaving with other expressions in larger statements.
• If X raises an exception (e.g., AttributeError, TypeError), the exception type and timing remain identical; however, if X returns a non-int that defines __index__ but not bit_count (e.g., custom numeric type), the rewrite will raise AttributeError where the original would succeed after bin conversion.
• If X returns a float, both versions raise TypeError, but the original does so during bin() conversion while the rewrite raises AttributeError on bit_count lookup, altering the exception type.
• If X returns a bool, both work (bool inherits bit_count), but the rewrite may be misleading stylistically though behaviorally equivalent.
• If X is an expression whose value is used elsewhere in the same statement (e.g., in a tuple or assignment), the rewrite preserves the value and any side effects, but intermediate reuse of X is not possible since it's evaluated once in both forms.
• If X is a conditional expression like a if cond else b, the rewrite preserves short-circuiting behavior identically.
• If the code contains a comment between bin( and .count (e.g., bin(/* hint */x).count('1')), the autofix will drop the comment as it only preserves the inner expression.
• If X is a lambda or comprehension that captures local state, the rewrite preserves capture semantics since evaluation is otherwise identical.
• If X is a super() call or attribute access on a nested object (e.g., bin(self.obj.x).count('1')), the rewrite preserves the same attribute lookup chain.
• If the code relies on bin(X) returning a string for further use (impossible here since .count('1') is chained), no issue arises—the intermediate string is never accessible.

TypeError 'float' object cannot be interpreted as an integer
AttributeError 'float' object has no attribute 'bit_count'

h called
g called
g called
g called

[[], [1]]

2
2

5
[7, 3]

--- orig.py	2026-10-17 17:34:12.949814493 -0400
+++ fixed.py	2026-10-17 17:34:13.111812519 -0400
@@ -7,5 +7,5 @@
     def __exit__(self, *args):
         pass
 with Writable() as w:
-    w.write(str(bin(15).count('1')))
+    w.write(str((15).bit_count()))
 print(w.data)

['4']

42
3

RuntimeError worse
ValueError bad

a_bool=False a_len=1 a_is_none=False
b_bool=False b_len=0 b_is_none=False
c_bool=True c_len=1 c_is_none=False

Start: []
After bin(log(3)).count('1'): ['called 3']
Error: AttributeError: 'str' object has no attribute 'bit_count'
After bin(log(5)).bit_count(): ['reset', 'called 5']

f then g: side=['f', 'g'], result=5
bin(f) then g: side=['f', 'g'], result=7

Testing bin(a() if cond else b()).count('1'):
b called
Testing bin(a() if cond else b()).count('1'):
a called
Testing bin(a() if cond else b()).bit_count():
b called
  Error: AttributeError: 'str' object has no attribute 'bit_count'
Testing bin(a() if cond else b()).bit_count():
a called
  Error: AttributeError: 'str' object has no attribute 'bit_count'

process(5) = 2
Annotations: {'x': <class 'int'>, 'return': <class 'int'>}
Error checking annotation: TypeError: 'type' object cannot be interpreted as an integer