Conformance tests and spec change for generic type erasure

python · hauntsaninja · Jan 19, 2024 · Jan 16, 2024 · Jan 16, 2024 · Jan 16, 2024
commit cd81f97c1ed5702f18c826e5b22ee716f41c580d
diff --git a/conformance/tests/generics_type_erasure.py b/conformance/tests/generics_type_erasure.py
@@ -0,0 +1,54 @@
+# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#instantiating-generic-classes-and-type-erasure
+
+from typing import Any, TypeVar, Generic, assert_type
+
+T = TypeVar("T")
+
+# > If the constructor (__init__ or __new__) uses T in its signature, and a
+# > corresponding argument value is passed, the type of the corresponding
+# > argument(s) is substituted. Otherwise, Any is assumed.
+
+class Node(Generic[T]):
+    label: T
+    def __init__(self, label: T | None = None) -> None: ...
+
+assert_type(Node(''), Node[str])
+assert_type(Node(0), Node[int])
+assert_type(Node(), Node[Any])
+
+assert_type(Node(0).label, int)
+assert_type(Node().label, Any)
+
+# > In case the inferred type uses [Any] but the intended type is more specific,
+# > you can use an annotation to force the type of the variable, e.g.:
+
+n1: Node[int] = Node()
+assert_type(n1, Node[int])
+n2: Node[str] = Node()
+assert_type(n2, Node[str])
+
+n3 = Node[int]()
+assert_type(n3, Node[int])
+n4 = Node[str]()
+assert_type(n4, Node[str])
+
+n5 = Node[int](0)   # OK
+n6 = Node[int]("")  # Type error
+n7 = Node[str]("")  # OK
+n8 = Node[str](0)   # Type error
+
+Node[int].label = 1  # Type error
+Node[int].label      # Type error
+Node.label = 1       # Type error
+Node.label           # Type error
+type(n1).label       # Type error
+assert_type(n1.label, int)
+assert_type(Node[int]().label, int)
+n1.label = 1         # OK
+
+# > [...] generic versions of concrete collections can be instantiated:
+
+from typing import DefaultDict
+
+data = DefaultDict[int, bytes]()
+assert_type(data[0], bytes)
diff --git a/docs/spec/generics.rst b/docs/spec/generics.rst
@@ -333,15 +333,15 @@ argument(s) is substituted.  Otherwise, ``Any`` is assumed.  Example::
 
   class Node(Generic[T]):
       x: T # Instance attribute (see below)
-      def __init__(self, label: T = None) -> None:
+      def __init__(self, label: T | None = None) -> None:
           ...
 
   x = Node('')  # Inferred type is Node[str]
   y = Node(0)   # Inferred type is Node[int]
   z = Node()    # Inferred type is Node[Any]
 
 In case the inferred type uses ``[Any]`` but the intended type is more
-specific, you can use a type comment (see below) to force the type of
+specific, you can use an annotation (see below) to force the type of
 the variable, e.g.::
 
   # (continued from previous example)
@@ -373,8 +373,8 @@ class instance that does not have an instance attribute with the same name::
   Node.x = 1       # Error
   Node.x           # Error
   type(p).x        # Error
-  p.x              # Ok (evaluates to None)
-  Node[int]().x    # Ok (evaluates to None)
+  p.x              # Ok (evaluates to int)
+  Node[int]().x    # Ok (evaluates to int)
   p.x = 1          # Ok, but assigning to instance attribute
 
 Generic versions of abstract collections like ``Mapping`` or ``Sequence``