ruff TC006

• If the first argument is a variable name (e.g., cast(T, x)), quoting it changes it from a type reference to a string literal, causing a runtime error when the type checker expects a type but receives a string.
• If the first attribute is a class or type imported locally (not from typing), quoting it prevents actual type resolution at runtime, breaking isinstance or issubclass checks that might rely on the cast target.
• If the type expression spans multiple lines (even without comments), the autofix may incorrectly quote only the first line or fail to preserve line breaks, resulting in a syntax error.
• If the first argument contains a comment on any line except the last, the fix may be applied incorrectly or omitted by Ruff due to its safety condition, but if forced, could comment out part of the type expression.
• If the cast call uses keyword arguments like cast(typ=MyType, val=x), the autofix may not recognize the structure and either misapply quotes or fail to fire, leading to inconsistent fixes.
• If the type expression contains a forward reference that is only resolved during TYPE_CHECKING, quoting it is correct, but if the same expression appears in a runtime context elsewhere, the inconsistency may mask circular import issues.
• If the type expression is a string literal already but uses single quotes (e.g., cast('int', x)), the rule may not fire (depending on configuration), but if it did and the fix added outer quotes, it would produce a malformed nested string like cast(''int'', x).
• If the code relies on the type expression being evaluated for side effects (e.g., a function call that returns a type), quoting it prevents execution, removing those side effects and potentially altering program state.
• If the cast is inside a lambda or comprehension and the type expression references a loop variable, quoting it changes the meaning from a dynamic type lookup to a static string, breaking intended behavior.
• If the type expression uses the | union operator (Python 3.10+) like cast(int | str, x), quoting it is necessary for forward compatibility, but if the code is run on Python <3.10, the unquoted version would already fail, so the fix doesn't introduce new breakage but assumes the target environment supports the syntax.
• If the first argument is a tuple or other container mistakenly used as a type (e.g., cast((int, str), x)), quoting it hides the fact that it's not a valid type annotation, delaying detection of a logical error until type checking fails.

--- orig.py	2026-10-17 16:42:02.145379343 -0400
+++ fixed.py	2026-10-17 16:42:02.330385991 -0400
@@ -4,7 +4,7 @@
     x = [1, 2, 3]
     try:
         # This should work: T is a type
-        y = cast(T, x)
+        y = cast('T', x)
         print('Before fix:', len(y))
     except Exception as e:
         print('Error before fix:', type(e).__name__, str(e))

Before fix: 3
Error in isinstance: TypeError Subscripted generics cannot be used with class and instance checks

--- orig.py	2026-10-17 16:42:02.436389801 -0400
+++ fixed.py	2026-10-17 16:42:02.624396557 -0400
@@ -9,7 +9,7 @@
     try:
         # This cast has a multiline first argument
         result = cast(
-            MyType,
+            'MyType',
             data
         )
         print('Success:', result['a'])

Success: [1, 2]
Broken form would fail to parse

--- orig.py	2026-10-17 16:42:02.732400438 -0400
+++ fixed.py	2026-10-17 16:42:03.133414842 -0400
@@ -4,13 +4,13 @@
 def main():
     x = 'hello'
     # First use: T refers to shadowed list (which is str)
-    y = cast(T, x)  # Should be cast(str, x)
+    y = cast('T', x)  # Should be cast(str, x)
     print('After cast:', y.upper() if isinstance(y, str) else 'fail')
     # Later, redefine list back to builtin
     del list  # Restore builtin
     list = lambda x: x  # Redefine as identity
     T = list  # Now T is the lambda
-    z = cast(T, x)  # cast(lambda, x) -> invalid type
+    z = cast('T', x)  # cast(lambda, x) -> invalid type
     try:
         # This won't fail at runtime, but type checker will complain
         print('z:', z)

--- orig.py	2026-10-17 16:42:03.355422809 -0400
+++ fixed.py	2026-10-17 16:42:03.678434400 -0400
@@ -6,7 +6,7 @@
 async def main():
     # cast in async context
     g = gen()
-    ag = cast(AsyncIterator[int], g)  # Rule fires here
+    ag = cast('AsyncIterator[int]', g)  # Rule fires here
     try:
         result = []
         async for item in ag:

Collected: [0, 1, 2]

--- orig.py	2026-10-17 16:42:03.856440788 -0400
+++ fixed.py	2026-10-17 16:42:04.048447675 -0400
@@ -2,21 +2,21 @@
 def main():
     x = [1, 2, 3]
     # Keyword form: should trigger rule on typ=
-    y = cast(typ=List[int], val=x)
+    y = cast(typ='List[int]', val=x)
     print('Length via keyword:', len(y))
     # After fix: autofix might not recognize keyword args and do nothing
     # Or worse, quote the first positional arg (which doesn't exist)
     # Simulate bad fix: if it tried to quote 'typ' or messed up keywords
     try:
         # This is safe: keyword args are preserved
-        z = cast(typ=List[int], val=[4, 5])
+        z = cast(typ='List[int]', val=[4, 5])
         print('Second call:', z)
     except Exception as e:
         print('Error in keyword cast:', type(e).__name__, str(e))
     # To show dependency: if we change List[int] to a var, and fix breaks
     T = List[int]
     # Rule should fire on typ=T
-    w = cast(typ=T, val=x)
+    w = cast(typ='T', val=x)
     print('Via var:', len(w))
 if __name__ == '__main__':
     main()

Length via keyword: 3
Second call: [4, 5]
Via var: 3

--- orig.py	2026-10-17 16:42:04.163451796 -0400
+++ fixed.py	2026-10-17 16:42:04.347458390 -0400
@@ -4,7 +4,7 @@
     x = (1, 'hello')
     # This is wrong: (int, str) is a tuple, not a type
     # Rule TC006 should fire because it's unquoted
-    y = cast((int, str), x)  # Expect trigger: first arg is tuple literal
+    y = cast('int, str', x)  # Expect trigger: first arg is tuple literal
     print('Cast result:', y, type(y))
     # At runtime, this succeeds because cast ignores the type argument
     # But if we later try to use (int, str) as a type in isinstance, it fails

Cast result: (1, 'hello') <class 'tuple'>
isinstance check failed
Eval succeeded: (<class 'int'>, <class 'str'>)

Value: 42 <class 'int'>
Single-quoted cast worked as expected

--- orig.py	2026-10-17 16:42:04.617468065 -0400
+++ fixed.py	2026-10-17 16:42:04.798474551 -0400
@@ -3,7 +3,7 @@
 def process(items):
     """Process a list of integers."""
     # Cast with trailing comment
-    result = cast(List[int], items)  # Ensure it's ints
+    result = cast('List[int]', items)  # Ensure it's ints
     # Another comment
     total = 0
     for x in result:

Total: 6
Comment preservation affects readability, not runtime

--- orig.py	2026-10-17 16:42:10.848690314 -0400
+++ fixed.py	2026-10-17 16:42:11.033696885 -0400
@@ -6,6 +6,6 @@
         pass
 def f():
     with Ctx() as c:
-        x = typing.cast(list[int], [c])
+        x = typing.cast("list[int]", [c])
         return sum(x)
 print(f())

42

--- orig.py	2026-10-17 16:42:11.163701496 -0400
+++ fixed.py	2026-10-17 16:42:11.340707775 -0400
@@ -3,7 +3,7 @@
 def g():
     a = 10
     b = 3
-    res = typing.cast(float, a / b)
+    res = typing.cast('float', a / b)
     rounded = round(res, 2)
     d = Decimal(str(res))
     print(f'{res:.2f}', rounded, d)

3.33 3.33 3.3333333333333335

--- orig.py	2026-10-17 16:42:11.448711607 -0400
+++ fixed.py	2026-10-17 16:42:11.865726400 -0400
@@ -4,5 +4,5 @@
     from typing import List
     MyType = List[int]
 x = 5
-y = typing.cast(MyType, [x])  # Rule triggers: MyType is not a string
+y = typing.cast("MyType", [x])  # Rule triggers: MyType is not a string
 print(sum(y))

--- orig.py	2026-10-17 16:42:11.976730337 -0400
+++ fixed.py	2026-10-17 16:42:12.156736715 -0400
@@ -1,5 +1,5 @@
 import typing
 def h(x):
-    return typing.cast(int | str, x)
+    return typing.cast('int | str', x)
 print(h(123))
 print(h('abc'))

123
abc

--- orig.py	2026-10-17 16:42:12.267740647 -0400
+++ fixed.py	2026-10-17 16:42:12.448747059 -0400
@@ -1,6 +1,6 @@
 import typing
 def i():
     name = 'Bob'
-    val = typing.cast(list[int], [len(f'{name!r}')])
+    val = typing.cast('list[int]', [len(f'{name!r}')])
     return sum(val)
 print(i())

5

--- orig.py	2026-10-17 16:42:12.549750637 -0400
+++ fixed.py	2026-10-17 16:42:12.732757119 -0400
@@ -1,4 +1,4 @@
 import typing
 j = 7
-k = typing.cast(list[int], [j])  # This is a list of one int
+k = typing.cast("list[int]", [j])  # This is a list of one int
 print(k[0] + 1)

8

True

--- orig.py	2026-10-17 16:42:12.995766436 -0400
+++ fixed.py	2026-10-17 16:42:13.176772839 -0400
@@ -2,7 +2,7 @@
 def bad(l=None):
     if l is None:
         l = []
-    l.append(typing.cast(int, len(l)))
+    l.append(typing.cast("int", len(l)))
     return l
 print(bad())
 print(bad())

[0]
[0]
[0]