ruff RUF057

• If expr has side effects (e.g., a function call), removing round may alter evaluation timing relative to other expressions.
• If expr is a variable whose type cannot be statically proven as int, the fix may incorrectly apply at runtime for non-int values (e.g., float).
• If expr is a boolean, replacing round(bool, 0) with the bool changes the type from int to bool, potentially breaking downstream int-specific operations.
• If expr is used elsewhere in the same line, removing round may affect operator precedence or grouping (e.g., in round(a+b, 0)*2 vs (a+b)*2).
• If round appears in a larger expression where its return value is ignored, deleting it may preserve value but alter side-effect visibility in debugging or tracing tools.
• If the code relies on round returning a float subclass (unlikely but possible via overrides), replacing with expr may change the return type.
• If expr is a constant that overflows in int context but not in float, the transformation could change value (though Python ints are arbitrary precision, this is negligible).
• If the round call is inside a lambda or comprehension, removing it may affect JIT or optimization assumptions in some implementations.
• If comments are attached to the round call (e.g., # tolerance), the fix may discard them if not preserved during rewrite.
• If expr is a named expression (walrus) like round((y := f()), 0), removing round may change the scope or timing of y's assignment.

side

<class 'int'> True

<class 'int'> 1
int op ok: 2

with round: 9
without round: 9
equal? True

pi rounded: 3.0

result: 5 # tolerance comment lost after fix?

called

a: 1 b: 2

Before: <lambda>
x: 5 <class 'int'>
z: 3 <class 'int'>

--- orig.py	2026-10-17 17:49:00.517917885 -0400
+++ fixed.py	2026-10-17 17:49:00.680945938 -0400
@@ -1,4 +1,4 @@
-def func(a, b=round(5, 0), *, c=round(10, 0)):
+def func(a, b=5, *, c=10):
     print(f'a={a}, b={b}, c={c}')
     return b + c
 
@@ -35,7 +35,7 @@
 # No difference.
 # We make the default expression be used in the function body in a way that its value is used multiple times — but the default value is fixed.
 # Example:
-def func3(a, b=round(5, 0)):
+def func3(a, b=5):
     print(b)
     print(b)  # uses same value
 # After fix: b=5 -> prints 5 twice.
@@ -77,7 +77,7 @@
 # To get multiple evaluations, we need the default to be re-evaluated — impossible.
 # We abandon and use: the function is called with b omitted, and we inspect the default value via func.__defaults__.
 print('--- Hazard 4: Defaults ---')
-def func5(a, b=round(5, 0)):
+def func5(a, b=5):
     return b
 
 print('func5.__defaults__:', func5.__defaults__)

First call:
func4: b=1, list=[1, 1, 1]
Second call:
func4: b=1, list=[1, 1, 1]
--- Hazard 4: Defaults ---
func5.__defaults__: (5,)
func6.__defaults__: (1,)
func6.__defaults__: (1,)

--- Hazard 5: Lambda/comprehension ---
Lambda result: 1 <class 'int'>
List comp: [1, 1] [<class 'int'>, <class 'int'>]
Lambda call: 1
After lambda: 3
List comp: [1, 1]
After comp: 2
Lambda result type: <class 'int'>
List comp types: [<class 'int'>, <class 'int'>]

--- Hazard 6: Boolean type change ---
Index result: one
Type is int
type(round(True,0)): <class 'int'>
type(True): <class 'bool'>
memoryview len: 1
memoryview len: 1
List with one element:
[round(True, 0)]: [1]
[True]: [True]

--- Hazard 7: Evaluation order and side effects ---
--- Hazard 7: Side effects in round call itself ---
Before any calls:
  my_round called with 5, 0
After round(5,0): x = 5
---
With built-in round:
x2 = 5

--- Hazard 8: File modes and truncation ---
Writing to file...
File content: '1'