fix: support nesting annotations when detecting ClassVar fields in dataclasses

Author: taminomara

Lib/dataclasses.py

@@ -762,9 +762,8 @@ def _is_kw_only(a_type, dataclasses):
     return a_type is dataclasses.KW_ONLY
 
 
-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.
+def _get_type_from_annotation(annotation, cls):
+    # Loosely parse a string annotation and return its type.
 
     # 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
@@ -773,9 +772,6 @@ def _is_type(annotation, cls, is_type_predicate, *is_type_predicate_args):
 
     # - annotation is a string type annotation
     # - cls is the class that this annotation was found in
-    # - 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
@@ -806,25 +802,21 @@ def _is_type(annotation, cls, is_type_predicate, *is_type_predicate_args):
     # https://github.com/python/cpython/issues/77634 for details.
     global _MODULE_IDENTIFIER_RE
     if _MODULE_IDENTIFIER_RE is None:
-        _MODULE_IDENTIFIER_RE = re.compile(r'(?:\s*(\w+)\s*\.)?\s*(\w+)')
+        _MODULE_IDENTIFIER_RE = re.compile(r'^\s*(\w+(?:\s*\.\s*\w+)*)')
 
     match = _MODULE_IDENTIFIER_RE.prefixmatch(annotation)
     if not match:
-        return False
-
-    module_name = match.group(1)
-    type_name = match.group(2)
+        return None
 
-    if not module_name:
-        # No module name, assume the class's module did
-        # "from dataclasses import InitVar".
-        ns = sys.modules.get(cls.__module__)
-    else:
-        # Look up module_name in the class's module.
-        cls_module = sys.modules.get(cls.__module__)
-        ns = cls_module.__dict__.get(module_name)
+    # Note: _MODULE_IDENTIFIER_RE guarantees that path is non-empty
+    path = match.group(1).split(".")
+    root = sys.modules.get(cls.__module__)
+    for path_item in path:
+        root = getattr(root, path_item.strip(), None)
+        if root is None:
+            return None
 
-    return is_type_predicate(getattr(ns, type_name, None), *is_type_predicate_args)
+    return root
 
 
 def _get_field(cls, a_name, a_type, default_kw_only):
@@ -862,16 +854,18 @@ def _get_field(cls, a_name, a_type, default_kw_only):
     # is actually of the correct type.
 
     # For the complete discussion, see https://bugs.python.org/issue33453
+    if isinstance(a_type, str):
+        a_type_annotation = _get_type_from_annotation(a_type, cls)
+    else:
+        a_type_annotation = a_type
 
     # If typing has not been imported, then it's impossible for any
     # annotation to be a ClassVar.  So, only look for ClassVar if
     # typing has been imported by any module (not necessarily cls's
     # module).
     typing = sys.modules.get('typing')
     if typing:
-        if (_is_classvar(a_type, typing)
-            or (isinstance(f.type, str)
-                and _is_type(f.type, cls, _is_classvar, typing))):
+        if _is_classvar(a_type_annotation, typing):
             f._field_type = _FIELD_CLASSVAR
 
     # If the type is InitVar, or if it's a matching string annotation,
@@ -880,9 +874,7 @@ def _get_field(cls, a_name, a_type, default_kw_only):
         # The module we're checking against is the module we're
         # currently in (dataclasses.py).
         dataclasses = sys.modules[__name__]
-        if (_is_initvar(a_type, dataclasses)
-            or (isinstance(f.type, str)
-                and _is_type(f.type, cls, _is_initvar, dataclasses))):
+        if _is_initvar(a_type_annotation, dataclasses):
             f._field_type = _FIELD_INITVAR
 
     # Validations for individual fields.  This is delayed until now,
@@ -1053,9 +1045,11 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
     dataclasses = sys.modules[__name__]
     for name, type in cls_annotations.items():
         # 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, _is_kw_only, dataclasses))):
+        if isinstance(type, str):
+            a_type_annotation = _get_type_from_annotation(type, cls)
+        else:
+            a_type_annotation = type
+        if _is_kw_only(a_type_annotation, 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

@@ -4643,6 +4643,14 @@ def custom_dataclass(cls, *args, **kwargs):
         self.assertEqual(c.x, 10)
         self.assertEqual(c.__custom__, True)
 
+    def test_empty_annotation_string(self):
+        @dataclass
+        class DataclassWithEmptyTypeAnnotation:
+            x: ""
+
+        c = DataclassWithEmptyTypeAnnotation(10)
+        self.assertEqual(c.x, 10)
+
 
 class TestReplace(unittest.TestCase):
     def test(self):

Lib/test/test_dataclasses/dataclass_module_4.py

@@ -9,29 +9,30 @@
 import typing
 
 class TypingProxy:
-    ClassVar = typing.ClassVar
-    InitVar = dataclasses.InitVar
+    class Nested:
+        ClassVar = typing.ClassVar
+        InitVar = dataclasses.InitVar
 
-T_CV2 = TypingProxy.ClassVar[int]
-T_CV3 = TypingProxy.ClassVar
+T_CV2 = TypingProxy.Nested.ClassVar[int]
+T_CV3 = TypingProxy.Nested.ClassVar
 
-T_IV2 = TypingProxy.InitVar[int]
-T_IV3 = TypingProxy.InitVar
+T_IV2 = TypingProxy.Nested.InitVar[int]
+T_IV3 = TypingProxy.Nested.InitVar
 
 @dataclass
 class CV:
-    T_CV4 = TypingProxy.ClassVar
-    cv0: TypingProxy.ClassVar[int] = 20
-    cv1: TypingProxy.ClassVar = 30
+    T_CV4 = TypingProxy.Nested.ClassVar
+    cv0: TypingProxy.Nested.ClassVar[int] = 20
+    cv1: TypingProxy.Nested.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
+    T_IV4 = TypingProxy.Nested.InitVar
+    iv0: TypingProxy.Nested.InitVar[int]
+    iv1: TypingProxy.Nested.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

@@ -9,29 +9,30 @@
 import typing
 
 class TypingProxy:
-    ClassVar = typing.ClassVar
-    InitVar = dataclasses.InitVar
+    class Nested:
+        ClassVar = typing.ClassVar
+        InitVar = dataclasses.InitVar
 
-T_CV2 = TypingProxy.ClassVar[int]
-T_CV3 = TypingProxy.ClassVar
+T_CV2 = TypingProxy.Nested.ClassVar[int]
+T_CV3 = TypingProxy.Nested.ClassVar
 
-T_IV2 = TypingProxy.InitVar[int]
-T_IV3 = TypingProxy.InitVar
+T_IV2 = TypingProxy.Nested.InitVar[int]
+T_IV3 = TypingProxy.Nested.InitVar
 
 @dataclass
 class CV:
-    T_CV4 = TypingProxy.ClassVar
-    cv0: TypingProxy.ClassVar[int] = 20
-    cv1: TypingProxy.ClassVar = 30
+    T_CV4 = TypingProxy.Nested.ClassVar
+    cv0: TypingProxy.Nested.ClassVar[int] = 20
+    cv1: TypingProxy.Nested.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
+    T_IV4 = TypingProxy.Nested.InitVar
+    iv0: TypingProxy.Nested.InitVar[int]
+    iv1: TypingProxy.Nested.InitVar
     iv2: T_IV2
     iv3: T_IV3
     not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.