3.9 ast

docs/contributing/ast/python3_9.ast

@@ -1,70 +1,66 @@
 -- Python 3.8 AST
--- ASDL's 5 builtin types are:
--- identifier, int, string, object, constant
+-- ASDL's 4 builtin types are:
+-- identifier, int, string, constant
 
-module Python version "3.8"
+module Python version "3.9"
 {
-    mod = Module(stmt* body, type_ignore *type_ignores)
+    mod = Module(stmt* body, type_ignore* type_ignores)
         | Interactive(stmt* body)
         | Expression(expr body)
         | FunctionType(expr* argtypes, expr returns)
 
-        -- not really an actual node but useful in Jython's typesystem.
-        | Suite(stmt* body)
-
     stmt = FunctionDef(identifier name,
                        arguments args,
                        stmt* body,
                        expr* decorator_list,
                        expr? returns,
                        string? type_comment)
-         | AsyncFunctionDef(identifier name,
-                            arguments args,
-                            stmt* body,
-                            expr* decorator_list,
-                            expr? returns,
-                            string? type_comment)
-
-         | ClassDef(identifier name,
-                    expr* bases,
-                    keyword* keywords,
-                    stmt* body,
-                    expr* decorator_list)
-         | Return(expr? value)
-
-         | Delete(expr* targets)
-         | Assign(expr* targets, expr value, string? type_comment)
-         | AugAssign(expr target, operator op, expr value)
-         -- 'simple' indicates that we annotate simple name without parens
-         | AnnAssign(expr target, expr annotation, expr? value, int simple)
-
-         -- use 'orelse' because else is a keyword in target languages
-         | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
-         | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
-         | While(expr test, stmt* body, stmt* orelse)
-         | If(expr test, stmt* body, stmt* orelse)
-         | With(withitem* items, stmt* body, string? type_comment)
-         | AsyncWith(withitem* items, stmt* body, string? type_comment)
-
-         | Raise(expr? exc, expr? cause)
-         | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
-         | Assert(expr test, expr? msg)
-
-         | Import(alias* names)
-         | ImportFrom(identifier? module, alias* names, int? level)
-
-         | Global(identifier* names)
-         | Nonlocal(identifier* names)
-         | Expr(expr value)
-         | Pass
-         | Break
-         | Continue
-
-         -- XXX Jython will be different
-         -- col_offset is the byte offset in the utf8 string the parser uses
-         attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
-
-         -- BoolOp() can use left & right?
+          | AsyncFunctionDef(identifier name,
+                             arguments args,
+                             stmt* body,
+                             expr* decorator_list,
+                             expr? returns,
+                             string? type_comment)
+
+          | ClassDef(identifier name,
+                     expr* bases,
+                     keyword* keywords,
+                     stmt* body,
+                     expr* decorator_list)
+          | Return(expr? value)
+
+          | Delete(expr* targets)
+          | Assign(expr* targets, expr value, string? type_comment)
+          | AugAssign(expr target, operator op, expr value)
+          -- 'simple' indicates that we annotate simple name without parens
+          | AnnAssign(expr target, expr annotation, expr? value, int simple)
+
+          -- use 'orelse' because else is a keyword in target languages
+          | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
+          | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
+          | While(expr test, stmt* body, stmt* orelse)
+          | If(expr test, stmt* body, stmt* orelse)
+          | With(withitem* items, stmt* body, string? type_comment)
+          | AsyncWith(withitem* items, stmt* body, string? type_comment)
+
+          | Raise(expr? exc, expr? cause)
+          | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
+          | Assert(expr test, expr? msg)
+
+          | Import(alias* names)
+          | ImportFrom(identifier? module, alias* names, int? level)
+
+          | Global(identifier* names)
+          | Nonlocal(identifier* names)
+          | Expr(expr value)
+          | Pass
+          | Break
+          | Continue
+
+          -- col_offset is the byte offset in the utf8 string the parser uses
+          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
+
+          -- BoolOp() can use left & right?
     expr = BoolOp(boolop op, expr* values)
          | NamedExpr(expr target, expr value)
          | BinOp(expr left, operator op, expr right)
@@ -84,34 +80,28 @@ module Python version "3.8"
          -- need sequences for compare to distinguish between
          -- x < 4 < 3 and (x < 4) < 3
          | Compare(expr left, cmpop* ops, expr* comparators)
-         | Call(expr func,
-                expr* args,
-                keyword* keywords)
+         | Call(expr func, expr* args, keyword* keywords)
          | FormattedValue(expr value, int? conversion, expr? format_spec)
          | JoinedStr(expr* values)
          | Constant(constant value, string? kind)
 
          -- the following expression can appear in assignment context
          | Attribute(expr value, identifier attr, expr_context ctx)
-         | Subscript(expr value, slice slice, expr_context ctx)
+         | Subscript(expr value, expr slice, expr_context ctx)
          | Starred(expr value, expr_context ctx)
          | Name(identifier id, expr_context ctx)
          | List(expr* elts, expr_context ctx)
          | Tuple(expr* elts, expr_context ctx)
 
-         -- col_offset is the byte offset in the utf8 string the parser uses
-         attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
+         -- can appear only in Subscript
+         | Slice(expr? lower, expr? upper, expr? step)
+
+          -- col_offset is the byte offset in the utf8 string the parser uses
+          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
 
     expr_context = Load
                  | Store
                  | Del
-                 | AugLoad
-                 | AugStore
-                 | Param
-
-    slice = Slice(expr? lower, expr? upper, expr? step)
-          | ExtSlice(slice* dims)
-          | Index(expr value)
 
     boolop = And
            | Or
@@ -164,6 +154,7 @@ module Python version "3.8"
 
     -- keyword arguments supplied to call (NULL identifier for **kwargs)
     keyword = (identifier? arg, expr value)
+              attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
 
     -- import name with optional 'as' alias.
     alias = (identifier name, identifier? asname)