Add .has_default() and update docs

python · JelleZijlstra · May 3, 2024 · Feb 29, 2024 · Feb 29, 2024 · Feb 29, 2024
commit 86f5aed920509fe3cddf70d798552b443e88ce7d
@@ -1756,9 +1756,17 @@ without the dedicated syntax, as documented below.
 
    .. attribute:: __default__
 
-      The default value of the type variable, if any. This attribute is ``None``
-      if the type variable has no default, and :class:`types.NoneType`
-      if the default is set to ``None``.
+      The default value of the type variable, or :data:`typing.NoDefault` if it
+      has no default.
+
+      .. versionadded:: 3.13
+
+   .. method:: has_default()
+
+      Return whether or not the type variable has a default value. This is equivalent
+      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
+      except that it does not force evaluation of the
+      :ref:`lazily evaluated <lazy-evaluation>` default value.
 
       .. versionadded:: 3.13
 
@@ -1886,9 +1894,17 @@ without the dedicated syntax, as documented below.
 
    .. attribute:: __default__
 
-      The default value of the type variable tuple, if any. This attribute is ``None``
-      if the type variable tuple has no default, and :class:`types.NoneType`
-      if the default is set to ``None``.
+      The default value of the type variable tuple, or :data:`typing.NoDefault` if it
+      has no default.
+
+      .. versionadded:: 3.13
+
+   .. method:: has_default()
+
+      Return whether or not the type variable tuple has a default value. This is equivalent
+      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
+      except that it does not force evaluation of the
+      :ref:`lazily evaluated <lazy-evaluation>` default value.
 
       .. versionadded:: 3.13
 
@@ -1974,9 +1990,17 @@ without the dedicated syntax, as documented below.
 
    .. attribute:: __default__
 
-      The default value of the parameter specification, if any. This attribute is ``None``
-      if the parameter specification has no default, and :class:`types.NoneType`
-      if the default is set to ``None``.
+      The default value of the parameter specification, or :data:`typing.NoDefault` if it
+      has no default.
+
+      .. versionadded:: 3.13
+
+   .. method:: has_default()
+
+      Return whether or not the parameter specification has a default value. This is equivalent
+      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
+      except that it does not force evaluation of the
+      :ref:`lazily evaluated <lazy-evaluation>` default value.
 
       .. versionadded:: 3.13
 
@@ -3213,9 +3237,9 @@ Introspection helpers
 
    A sentinel object used to indicate that a type parameter has no default
    value. For example:
-   
+
    .. doctest::
-   
+
       >>> T = TypeVar("T")
       >>> T.__default__ is typing.NoDefault
       True

@@ -6,7 +6,7 @@
 import weakref
 from test.support import requires_working_socket, check_syntax_error, run_code
 
-from typing import Generic, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args
+from typing import Generic, NoDefault, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args
 
 
 class TypeParamsInvalidTest(unittest.TestCase):
@@ -599,12 +599,12 @@ class Foo[T: Foo, U: (Foo, Foo)]:
         self.assertEqual(type_params[0].__name__, "T")
         self.assertIs(type_params[0].__bound__, Foo)
         self.assertEqual(type_params[0].__constraints__, ())
-        self.assertIs(type_params[0].__default__, None)
+        self.assertIs(type_params[0].__default__, NoDefault)
 
         self.assertEqual(type_params[1].__name__, "U")
         self.assertIs(type_params[1].__bound__, None)
         self.assertEqual(type_params[1].__constraints__, (Foo, Foo))
-        self.assertIs(type_params[1].__default__, None)
+        self.assertIs(type_params[1].__default__, NoDefault)
 
     def test_evaluation_error(self):
         class Foo[T: Undefined, U: (Undefined,)]:
@@ -615,8 +615,8 @@ class Foo[T: Undefined, U: (Undefined,)]:
             type_params[0].__bound__
         self.assertEqual(type_params[0].__constraints__, ())
         self.assertIs(type_params[1].__bound__, None)
-        self.assertIs(type_params[0].__default__, None)
-        self.assertIs(type_params[1].__default__, None)
+        self.assertIs(type_params[0].__default__, NoDefault)
+        self.assertIs(type_params[1].__default__, NoDefault)
         with self.assertRaises(NameError):
             type_params[1].__constraints__
 
@@ -1182,7 +1182,7 @@ def func[T=int, **U=float, *V=None]():
         T, U, V = ns["func"].__type_params__
         self.assertIs(T.__default__, int)
         self.assertIs(U.__default__, float)
-        self.assertIs(V.__default__, type(None))
+        self.assertIs(V.__default__, None)
 
     def test_defaults_on_class(self):
         ns = run_code("""
@@ -1193,7 +1193,7 @@ class C[T=int, **U=float, *V=None]:
         T, U, V = ns["C"].__type_params__
         self.assertIs(T.__default__, int)
         self.assertIs(U.__default__, float)
-        self.assertIs(V.__default__, type(None))
+        self.assertIs(V.__default__, None)
 
     def test_defaults_on_type_alias(self):
         ns = run_code("""
@@ -1203,7 +1203,7 @@ def test_defaults_on_type_alias(self):
         T, U, V = ns["Alias"].__type_params__
         self.assertIs(T.__default__, int)
         self.assertIs(U.__default__, float)
-        self.assertIs(V.__default__, type(None))
+        self.assertIs(V.__default__, None)
 
     def test_starred_invalid(self):
         check_syntax_error(self, "type Alias[T = *int] = int")

@@ -584,6 +584,7 @@ class TypeParameterDefaultsTests(BaseTestCase):
     def test_typevar(self):
         T = TypeVar('T', default=int)
         self.assertEqual(T.__default__, int)
+        self.assertTrue(T.has_default())
         self.assertIsInstance(T, TypeVar)
 
         class A(Generic[T]): ...
@@ -593,15 +594,19 @@ def test_typevar_none(self):
         U = TypeVar('U')
         U_None = TypeVar('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
+        self.assertFalse(U.has_default())
         self.assertIs(U_None.__default__, None)
+        self.assertTrue(U_None.has_default())
 
         class X[T]: ...
         T, = X.__type_params__
         self.assertIs(T.__default__, NoDefault)
+        self.assertFalse(T.has_default())
 
     def test_paramspec(self):
         P = ParamSpec('P', default=(str, int))
         self.assertEqual(P.__default__, (str, int))
+        self.assertTrue(P.has_default())
         self.assertIsInstance(P, ParamSpec)
 
         class A(Generic[P]): ...
@@ -614,15 +619,19 @@ def test_paramspec_none(self):
         U = ParamSpec('U')
         U_None = ParamSpec('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
+        self.assertFalse(U.has_default())
         self.assertIs(U_None.__default__, None)
+        self.assertTrue(U_None.has_default())
 
         class X[**P]: ...
         P, = X.__type_params__
         self.assertIs(P.__default__, NoDefault)
+        self.assertFalse(P.has_default())
 
     def test_typevartuple(self):
         Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]])
         self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]])
+        self.assertTrue(Ts.has_default())
         self.assertIsInstance(Ts, TypeVarTuple)
 
         class A(Generic[Unpack[Ts]]): ...
@@ -691,11 +700,14 @@ def test_typevartuple_none(self):
         U = TypeVarTuple('U')
         U_None = TypeVarTuple('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
+        self.assertFalse(U.has_default())
         self.assertIs(U_None.__default__, None)
+        self.assertTrue(U_None.has_default())
 
         class X[**Ts]: ...
         Ts, = X.__type_params__
         self.assertIs(Ts.__default__, NoDefault)
+        self.assertFalse(Ts.has_default())
 
     def test_no_default_after_non_default(self):
         DefaultStrT = TypeVar('DefaultStrT', default=str)

@@ -286,11 +286,11 @@ def _collect_parameters(args):
                         parameters.append(collected)
         elif hasattr(t, '__typing_subst__'):
             if t not in parameters:
-                if type_var_tuple_encountered and t.__default__ is not NoDefault:
+                if type_var_tuple_encountered and t.has_default():
                     raise TypeError('Type parameter with a default'
                                     ' follows TypeVarTuple')
 
-                if t.__default__ is not NoDefault:
+                if t.has_default():
                     default_encountered = True
                 elif default_encountered:
                     raise TypeError(f'Type parameter {t!r} without a default'
@@ -325,10 +325,10 @@ def _check_generic_specialization(cls, arguments):
             # the number of arguments being passed not matching the number
             # of parameters: all parameters that aren't explicitly
             # specialized in this call are parameters with default values.
-            if cls.__parameters__[actual_len].__default__ is not NoDefault:
+            if cls.__parameters__[actual_len].has_default():
                 return
 
-            expected_len -= sum(p.__default__ is not NoDefault for p in cls.__parameters__)
+            expected_len -= sum(p.has_default() for p in cls.__parameters__)
             expect_val = f"at least {expected_len}"
         else:
             expect_val = expected_len
@@ -1126,7 +1126,7 @@ def _typevartuple_prepare_subst(self, alias, args):
     elif left + right > alen:
         raise TypeError(f"Too few arguments for {alias};"
                         f" actual {alen}, expected at least {plen-1}")
-    if left == alen - right and self.__default__ is not NoDefault:
+    if left == alen - right and self.has_default():
         replacement = _unpack_args(self.__default__)
     else:
         replacement = args[left: alen - right]
@@ -1152,7 +1152,7 @@ def _paramspec_subst(self, arg):
 def _paramspec_prepare_subst(self, alias, args):
     params = alias.__parameters__
     i = params.index(self)
-    if i == len(args) and self.__default__ is not NoDefault:
+    if i == len(args) and self.has_default():
         args = [*args, self.__default__]
     if i >= len(args):
         raise TypeError(f"Too few arguments for {alias}")

diff --git a/Objects/clinic/typevarobject.c.h b/Objects/clinic/typevarobject.c.h