ruff RUF041

• Rewriting Literal[Literal[expr]] where expr has side effects (e.g., function calls) changes evaluation from once per inner Literal to once in the flattened version, altering call count.
• If inner Literals contain duplicate values, deduplication in the fix may break code relying on duplicate literal parameters for overload resolution or type narrowing.
• Moving inline comments attached to inner Literal brackets (e.g., Literal["a" # comment ]) to the flattened Literal may detach them from their original syntactic context, changing comment association.
• When nested Literals span multiple lines with trailing comments on some lines, the fix may reorder or lose those comments due to reformatting, violating the rule's noted unsafety condition.
• If the outer Literal is used in a forward reference or string annotation, flattening may break evaluation if the inner Literals were relied upon for delayed processing.
• In code that inspects the AST structure of Literal (e.g., via typing.get_args), the fix alters the nested structure expected by introspection tools or decorators.
• If an inner Literal contains a mutable expression (e.g., Literal[[]]), though invalid, the fix would still flatten it, potentially exposing differences in how type checkers handle malformed literals.
• When the nested Literal appears in a class body or function default, flattening could affect the timing of when the literal value is computed relative to other statements in the same block.
• If the inner Literals are defined via imports or aliases that are later rebound, the fix captures their values at rewrite time, breaking dynamic behavior.
• In code that uses Literal in conjunction with Final or ClassVar, flattening may interfere with how tools detect constantness if they rely on the Literal node structure.

--- orig.py	2026-10-17 17:45:09.538052614 -0400
+++ fixed.py	2026-10-17 17:45:09.722051411 -0400
@@ -1,6 +1,6 @@
 from typing import Literal
 int = lambda: print('custom_int')
-x = Literal[Literal['a', 'b']]
+x = Literal['a', 'b']
 print(int(), getattr(x, '__args__', x))
 del int
 int = 42

custom_int
None ('a', 'b')
42

('hello', 'world')

--- orig.py	2026-10-17 17:45:10.379047116 -0400
+++ fixed.py	2026-10-17 17:45:10.566045895 -0400
@@ -5,6 +5,6 @@
     counter += 1
     return counter
 class C:
-    x = Literal[Literal[inc()], Literal[inc()]]
+    x = Literal[inc(), inc()]
     y = counter
 print(C.x.__args__, C.y)

(1, 2) 2

--- orig.py	2026-10-17 17:45:10.670045215 -0400
+++ fixed.py	2026-10-17 17:45:10.858043986 -0400
@@ -1,4 +1,4 @@
 from typing import Literal, get_args
-x = Literal[Literal['a', 'b'], Literal['c']]
+x = Literal['a', 'b', 'c']
 args = get_args(x)
 print(len(args), [get_args(a) if hasattr(a, '__args__') else a for a in args])

3 ['a', 'b', 'c']

--- orig.py	2026-10-17 17:45:10.968043267 -0400
+++ fixed.py	2026-10-17 17:45:11.149042085 -0400
@@ -11,5 +11,5 @@
 w = Writer()
 with w as f:
     f.write('test')
-x = Literal[Literal['a'], Literal['b']]
+x = Literal['a', 'b']
 print(w.data, x.__args__)

['test'] ('a', 'b')

--- orig.py	2026-10-17 17:45:11.258041373 -0400
+++ fixed.py	2026-10-17 17:45:11.434040224 -0400
@@ -1,5 +1,5 @@
 from typing import Literal, Final, ClassVar
-NESTED = Literal[Literal['x'], Literal['y']]
+NESTED = Literal['x', 'y']
 FLAT: Final = Literal['x', 'y']
 CLASS_VAR: ClassVar = Literal['x', 'y']
 print(NESTED.__args__, FLAT.__args__, CLASS_VAR.__args__)

('x', 'y') ('x', 'y') ('x', 'y')

--- orig.py	2026-10-17 17:45:11.549039473 -0400
+++ fixed.py	2026-10-17 17:45:11.725038323 -0400
@@ -1,5 +1,5 @@
 from typing import Literal
-x = Literal[Literal['a', 'b'], Literal['c']]
+x = Literal['a', 'b', 'c']
 print(x.__args__)
 def side_effect():
     global x

('a', 'b', 'c')
('d',)

--- orig.py	2026-10-17 17:45:16.442007569 -0400
+++ fixed.py	2026-10-17 17:45:16.631006339 -0400
@@ -1,6 +1,6 @@
 from typing import Literal
 
-def func(a=Literal[Literal['x'], Literal['y']]):
+def func(a=Literal['x', 'y']):
     a.append('z') if hasattr(a, 'append') else None
     return a
 

typing.Literal['x', 'y']
typing.Literal['x', 'y']

--- orig.py	2026-10-17 17:45:16.747005584 -0400
+++ fixed.py	2026-10-17 17:45:16.943004308 -0400
@@ -1,6 +1,6 @@
 from typing import Literal
 
-x = Literal[Literal['hello'], Literal['world']]
+x = Literal['hello', 'world']
 s = '%s %s' % (x.__args__[0][0], x.__args__[1][0])
 print(s)
 print(f'{x.__args__[0][0]} {x.__args__[1][0]}')

h w
h w
typing.Literal['hello', 'world']
typing.Literal['hello', 'world']

('a', 'b')

--- orig.py	2026-10-17 17:45:17.247002330 -0400
+++ fixed.py	2026-10-17 17:45:17.446001035 -0400
@@ -9,7 +9,7 @@
     def write(self, s):
         self.data = s
 
-x = Literal[Literal['stdout'], Literal['stderr']]
+x = Literal['stdout', 'stderr']
 with WriteOnly() as w:
     w.write(str(x))
 print(w.data)

typing.Literal['stdout', 'stderr']

--- orig.py	2026-10-17 17:45:17.944997789 -0400
+++ fixed.py	2026-10-17 17:45:18.141996508 -0400
@@ -1,6 +1,6 @@
 from typing import Literal
 
-LIT = Literal[Literal['init']]
+LIT = Literal['init']
 
 class C:
     attr = LIT  # Evaluated at class definition time

typing.Literal['init']

--- orig.py	2026-10-17 17:45:18.261995728 -0400
+++ fixed.py	2026-10-17 17:45:18.448994512 -0400
@@ -1,7 +1,7 @@
 from typing import Literal
 
 def gen():
-    for item in Literal[Literal['a'], Literal['b']]:
+    for item in Literal['a', 'b']:
         yield item
 
 g = gen()

[typing.Unpack[typing.Literal['a', 'b']]]
[]

('alpha', 'beta')