ast changes, fix build

python · JelleZijlstra · May 26, 2023 · May 13, 2023 · May 15, 2023 · May 19, 2023
commit e3dfb2750f9317b224d2fc74b07a18a778f64be4
diff --git a/Doc/library/ast.rst b/Doc/library/ast.rst
@@ -917,6 +917,25 @@ Statements
             type_ignores=[])
 
 
+.. class:: TypeAlias(name, typeparams, value)
+
+   A type alias created through the :keyword:`type` statement. ``name``
+   is the name of the alias, ``typeparams`` is a list of
+   :ref:`type parameters <ast-type-params>`, and ``value`` is the value of the
+   type alias.
+
+   .. doctest::
+
+        >>> print(ast.dump(ast.parse('type Alias = int'), indent=4))
+        Module(
+            body=[
+                TypeAlias(
+                    name=Name(id='Alias', ctx=Store()),
+                    typeparams=[],
+                    value=Name(id='int', ctx=Load()))],
+            type_ignores=[])
+
+
 Other statements which are only applicable inside functions or loops are
 described in other sections.
 
@@ -1644,15 +1663,93 @@ Pattern matching
                                     value=Constant(value=Ellipsis))])])],
             type_ignores=[])
 
+.. _ast-type-params:
+
+Type parameters
+^^^^^^^^^^^^^^^
+
+:ref:`Type parameters <type-params>` can exist on classes, functions, and type
+aliases.
+
+.. class:: TypeVar(name, bound)
+
+   A :class:`~typing.TypeVar`. ``name`` is the name of the type variable, and
+   ``bound`` is the bound or constraints, if any. If the value is a :class:`Tuple`,
+   it represents constraints; otherwise it represents the bound.
+
+   .. doctest::
+
+        >>> print(ast.dump(ast.parse("type Alias[T: int] = list[T]"), indent=4))
+        Module(
+            body=[
+                TypeAlias(
+                    name=Name(id='Alias', ctx=Store()),
+                    typeparams=[
+                        TypeVar(
+                            name='T',
+                            bound=Name(id='int', ctx=Load()))],
+                    value=Subscript(
+                        value=Name(id='list', ctx=Load()),
+                        slice=Name(id='T', ctx=Load()),
+                        ctx=Load()))],
+            type_ignores=[])
+
+.. class:: ParamSpec(name)
+
+   A :class:`~typing.ParamSpec`. ``name`` is the name of the parameter specification.
+
+   .. doctest::
+
+        >>> print(ast.dump(ast.parse("type Alias[**P] = Callable[P, int]"), indent=4))
+        Module(
+            body=[
+                TypeAlias(
+                    name=Name(id='Alias', ctx=Store()),
+                    typeparams=[
+                        ParamSpec(name='P')],
+                    value=Subscript(
+                        value=Name(id='Callable', ctx=Load()),
+                        slice=Tuple(
+                            elts=[
+                                Name(id='P', ctx=Load()),
+                                Name(id='int', ctx=Load())],
+                            ctx=Load()),
+                        ctx=Load()))],
+            type_ignores=[])
+
+.. class:: TypeVarTuple(name)
+
+   A :class:`~typing.TypeVarTuple`. ``name`` is the name of the type variable tuple.
+
+   .. doctest::
+
+        >>> print(ast.dump(ast.parse("type Alias[*Ts] = tuple[*Ts]"), indent=4))
+        Module(
+            body=[
+                TypeAlias(
+                    name=Name(id='Alias', ctx=Store()),
+                    typeparams=[
+                        TypeVarTuple(name='Ts')],
+                    value=Subscript(
+                        value=Name(id='tuple', ctx=Load()),
+                        slice=Tuple(
+                            elts=[
+                                Starred(
+                                    value=Name(id='Ts', ctx=Load()),
+                                    ctx=Load())],
+                            ctx=Load()),
+                        ctx=Load()))],
+            type_ignores=[])
 
 Function and class definitions
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-.. class:: FunctionDef(name, args, body, decorator_list, returns, type_comment)
+.. class:: FunctionDef(name, typeparams, args, body, decorator_list, returns, type_comment)
 
    A function definition.
 
    * ``name`` is a raw string of the function name.
+   * ``typeparams`` is a list of :ref:`type parameters <ast-type-params>`.
    * ``args`` is an :class:`arguments` node.
    * ``body`` is the list of nodes inside the function.
    * ``decorator_list`` is the list of decorators to be applied, stored outermost
@@ -1820,11 +1917,12 @@ Function and class definitions
             type_ignores=[])
 
 
-.. class:: ClassDef(name, bases, keywords, starargs, kwargs, body, decorator_list)
+.. class:: ClassDef(name, typeparams, bases, keywords, starargs, kwargs, body, decorator_list)
 
    A class definition.
 
    * ``name`` is a raw string for the class name
+   * ``typeparams`` is a list of :ref:`type parameters <ast-type-params>`.
    * ``bases`` is a list of nodes for explicitly specified base classes.
    * ``keywords`` is a list of :class:`keyword` nodes, principally for 'metaclass'.
      Other keywords will be passed to the metaclass, as per `PEP-3115

@@ -1671,7 +1671,7 @@ For :data:`!typing.TypeVar`\ s declared using the type parameter list syntax,
 the bound and constraints are not evaluated when the generic object is created,
 but only when the value is explicitly accessed through the attributes ``__bound__``
 and ``__constraints__``. To accomplish this, the bounds or constraints are
-evaluated in a separate :ref:`type scope <type-scopes>`.
+evaluated in a separate :ref:`annotation scope <annotation-scopes>`.
 
 :data:`typing.TypeVarTuple`\ s and :data:`typing.ParamSpec`\ s cannot have bounds
 or constraints.
@@ -1792,11 +1792,11 @@ This is equivalent to::
 Generic type aliases
 --------------------
 
-The :keyword:`type` statement can also be used to create a generic type alias:
+The :keyword:`type` statement can also be used to create a generic type alias::
 
    type ListOrSet[T] = list[T] | set[T]
 
-Except for the lazy evaluation of the value, this is equivalent to:
+Except for the lazy evaluation of the value, this is equivalent to::
 
    def' TYPE_PARAMS_OF_ListOrSet():
        T = typing.TypeVar("T")
@@ -1807,8 +1807,6 @@ Except for the lazy evaluation of the value, this is equivalent to:
        return typing.TypeAliasType("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,))
    ListOrSet = TYPE_PARAMS_OF_ListOrSet()
 
-
-
 .. rubric:: Footnotes
 
 .. [#] The exception is propagated to the invocation stack unless

@@ -189,7 +189,7 @@ However, the following will succeed::
 Annotation scopes
 -----------------
 
-:ref:`Type parameter lists <type-params>`` and :keyword:`type` statements
+:ref:`Type parameter lists <type-params>` and :keyword:`type` statements
 introduce *annotation scopes*, which behave mostly like function scopes,
 but with some exceptions discussed below. :term:`Annotations <annotation>`
 currently do not use annotation scopes, but they are expected to use