fix: further improve detection of ClassVar in dataclass' string annotations

Author: taminomara

Lib/dataclasses.py

@@ -711,22 +711,20 @@ def _is_kw_only(a_type, dataclasses):
     return a_type is dataclasses.KW_ONLY
 
 
-def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
-    # Given a type annotation string, does it refer to a_type in
-    # a_module?  For example, when checking that annotation denotes a
-    # ClassVar, then a_module is typing, and a_type is
-    # typing.ClassVar.
+def _is_type(annotation, cls, is_type_predicate, *is_type_predicate_args):
+    # Loosely parse a string annotation and pass the result to is_type_predicate,
+    # along with any additional arguments it might require.
 
-    # It's possible to look up a_module given a_type, but it involves
-    # looking in sys.modules (again!), and seems like a waste since
-    # the caller already knows a_module.
+    # We can't perform a full type hint evaluation at the point where @dataclass
+    # was invoked because class's module is not fully initialized yet. So we resort
+    # to parsing string annotation using regexp, and extracting a type before
+    # the first square bracket.
 
     # - annotation is a string type annotation
     # - cls is the class that this annotation was found in
-    # - a_module is the module we want to match
-    # - a_type is the type in that module we want to match
-    # - is_type_predicate is a function called with (obj, a_module)
+    # - is_type_predicate is a function called with (obj, *is_type_predicate_args)
     #   that determines if obj is of the desired type.
+    # - is_type_predicate_args is additional arguments forwarded to is_type_predicate
 
     # Since this test does not do a local namespace lookup (and
     # instead only a module (global) lookup), there are some things it
@@ -756,30 +754,19 @@ def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
     if not match:
         return False
 
-    ns = None
     module_name = match.group(1)
     type_name = match.group(2)
 
     if not module_name:
         # No module name, assume the class's module did
         # "from dataclasses import InitVar".
-        ns = sys.modules.get(cls.__module__).__dict__
+        ns = sys.modules.get(cls.__module__)
     else:
         # Look up module_name in the class's module.
         cls_module = sys.modules.get(cls.__module__)
-        if not cls_module:
-            return False
+        ns = cls_module.__dict__.get(module_name)
 
-        a_type_module = cls_module.__dict__.get(module_name)
-        if (
-            isinstance(a_type_module, types.ModuleType)
-            # Handle cases when a_type is not defined in
-            # the referenced module, e.g. 'dataclasses.ClassVar[int]'
-            and a_type_module.__dict__.get(type_name) is a_type
-        ):
-            ns = sys.modules.get(a_type.__module__).__dict__
-
-    return ns and is_type_predicate(ns.get(type_name), a_module)
+    return is_type_predicate(getattr(ns, type_name, None), *is_type_predicate_args)
 
 
 def _get_field(cls, a_name, a_type, default_kw_only):
@@ -826,8 +813,7 @@ def _get_field(cls, a_name, a_type, default_kw_only):
     if typing:
         if (_is_classvar(a_type, typing)
             or (isinstance(f.type, str)
-                and _is_type(f.type, cls, typing, typing.ClassVar,
-                             _is_classvar))):
+                and _is_type(f.type, cls, _is_classvar, typing))):
             f._field_type = _FIELD_CLASSVAR
 
     # If the type is InitVar, or if it's a matching string annotation,
@@ -838,8 +824,7 @@ def _get_field(cls, a_name, a_type, default_kw_only):
         dataclasses = sys.modules[__name__]
         if (_is_initvar(a_type, dataclasses)
             or (isinstance(f.type, str)
-                and _is_type(f.type, cls, dataclasses, dataclasses.InitVar,
-                             _is_initvar))):
+                and _is_type(f.type, cls, _is_initvar, dataclasses))):
             f._field_type = _FIELD_INITVAR
 
     # Validations for individual fields.  This is delayed until now,
@@ -1012,8 +997,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
         # See if this is a marker to change the value of kw_only.
         if (_is_kw_only(type, dataclasses)
             or (isinstance(type, str)
-                and _is_type(type, cls, dataclasses, dataclasses.KW_ONLY,
-                             _is_kw_only))):
+                and _is_type(type, cls, _is_kw_only, dataclasses))):
             # Switch the default to kw_only=True, and ignore this
             # annotation: it's not a real field.
             if KW_ONLY_seen:

Lib/test/test_dataclasses/__init__.py

@@ -4095,11 +4095,14 @@ def test_classvar_module_level_import(self):
         from test.test_dataclasses import dataclass_module_2_str
         from test.test_dataclasses import dataclass_module_3
         from test.test_dataclasses import dataclass_module_3_str
+        from test.test_dataclasses import dataclass_module_4
+        from test.test_dataclasses import dataclass_module_4_str
 
         for m in (
             dataclass_module_1, dataclass_module_1_str,
             dataclass_module_2, dataclass_module_2_str,
             dataclass_module_3, dataclass_module_3_str,
+            dataclass_module_4, dataclass_module_4_str,
         ):
             with self.subTest(m=m):
                 # There's a difference in how the ClassVars are

Lib/test/test_dataclasses/dataclass_module_3_str.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 USING_STRINGS = True
 
-# dataclass_module_3.py and dataclass_module_2_str.py are identical
+# dataclass_module_3.py and dataclass_module_3_str.py are identical
 # except only the latter uses string annotations.
 
 from dataclasses import dataclass

Lib/test/test_dataclasses/dataclass_module_4.py

@@ -0,0 +1,37 @@
+#from __future__ import annotations
+USING_STRINGS = False
+
+# dataclass_module_4.py and dataclass_module_4_str.py are identical
+# except only the latter uses string annotations.
+
+from dataclasses import dataclass
+import dataclasses
+import typing
+
+class TypingProxy:
+    ClassVar = typing.ClassVar
+    InitVar = dataclasses.InitVar
+
+T_CV2 = TypingProxy.ClassVar[int]
+T_CV3 = TypingProxy.ClassVar
+
+T_IV2 = TypingProxy.InitVar[int]
+T_IV3 = TypingProxy.InitVar
+
+@dataclass
+class CV:
+    T_CV4 = TypingProxy.ClassVar
+    cv0: TypingProxy.ClassVar[int] = 20
+    cv1: TypingProxy.ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclass
+class IV:
+    T_IV4 = TypingProxy.InitVar
+    iv0: TypingProxy.InitVar[int]
+    iv1: TypingProxy.InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.

Lib/test/test_dataclasses/dataclass_module_4_str.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+USING_STRINGS = True
+
+# dataclass_module_4.py and dataclass_module_4_str.py are identical
+# except only the latter uses string annotations.
+
+from dataclasses import dataclass
+import dataclasses
+import typing
+
+class TypingProxy:
+    ClassVar = typing.ClassVar
+    InitVar = dataclasses.InitVar
+
+T_CV2 = TypingProxy.ClassVar[int]
+T_CV3 = TypingProxy.ClassVar
+
+T_IV2 = TypingProxy.InitVar[int]
+T_IV3 = TypingProxy.InitVar
+
+@dataclass
+class CV:
+    T_CV4 = TypingProxy.ClassVar
+    cv0: TypingProxy.ClassVar[int] = 20
+    cv1: TypingProxy.ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclass
+class IV:
+    T_IV4 = TypingProxy.InitVar
+    iv0: TypingProxy.InitVar[int]
+    iv1: TypingProxy.InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.

Misc/NEWS.d/next/Library/2025-05-16-01-43-58.gh-issue-133956.5kWDYd.rst

@@ -1 +1,4 @@
-Fix bug where ``ClassVar`` string annotation in :func:`@dataclass <dataclasses.dataclass>` caused incorrect __init__ generation
+Fix bug where :func:`@dataclass <dataclasses.dataclass>`
+wouldn't detect ``ClassVar`` fields
+if ``ClassVar`` was re-exported from a module
+other than :mod:`typing`.