]> git.madduck.net Git - etc/vim.git/blob - src/blib2to3/Grammar.txt

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

primer: Hypothesis now requires Python>=3.8 (GH-2602)
[etc/vim.git] / src / blib2to3 / Grammar.txt
1 # Grammar for 2to3. This grammar supports Python 2.x and 3.x.
2
3 # NOTE WELL: You should also follow all the steps listed at
4 # https://devguide.python.org/grammar/
5
6 # Start symbols for the grammar:
7 #       file_input is a module or sequence of commands read from an input file;
8 #       single_input is a single interactive statement;
9 #       eval_input is the input for the eval() and input() functions.
10 # NB: compound_stmt in single_input is followed by extra NEWLINE!
11 file_input: (NEWLINE | stmt)* ENDMARKER
12 single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
13 eval_input: testlist NEWLINE* ENDMARKER
14
15 decorator: '@' namedexpr_test NEWLINE
16 decorators: decorator+
17 decorated: decorators (classdef | funcdef | async_funcdef)
18 async_funcdef: ASYNC funcdef
19 funcdef: 'def' NAME parameters ['->' test] ':' suite
20 parameters: '(' [typedargslist] ')'
21
22 # The following definition for typedarglist is equivalent to this set of rules:
23 #
24 #     arguments = argument (',' argument)*
25 #     argument = tfpdef ['=' test]
26 #     kwargs = '**' tname [',']
27 #     args = '*' [tname]
28 #     kwonly_kwargs = (',' argument)* [',' [kwargs]]
29 #     args_kwonly_kwargs = args kwonly_kwargs | kwargs
30 #     poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]]
31 #     typedargslist_no_posonly  = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs
32 #     typedarglist = arguments ',' '/' [',' [typedargslist_no_posonly]])|(typedargslist_no_posonly)"
33 #
34 # It needs to be fully expanded to allow our LL(1) parser to work on it.
35
36 typedargslist: tfpdef ['=' test] (',' tfpdef ['=' test])* ',' '/' [
37                      ',' [((tfpdef ['=' test] ',')* ('*' [tname] (',' tname ['=' test])*
38                             [',' ['**' tname [',']]] | '**' tname [','])
39                      | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])]
40                 ] | ((tfpdef ['=' test] ',')* ('*' [tname] (',' tname ['=' test])*
41                      [',' ['**' tname [',']]] | '**' tname [','])
42                      | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
43
44 tname: NAME [':' test]
45 tfpdef: tname | '(' tfplist ')'
46 tfplist: tfpdef (',' tfpdef)* [',']
47
48 # The following definition for varargslist is equivalent to this set of rules:
49 #
50 #     arguments = argument (',' argument )*
51 #     argument = vfpdef ['=' test]
52 #     kwargs = '**' vname [',']
53 #     args = '*' [vname]
54 #     kwonly_kwargs = (',' argument )* [',' [kwargs]]
55 #     args_kwonly_kwargs = args kwonly_kwargs | kwargs
56 #     poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]]
57 #     vararglist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs
58 #     varargslist = arguments ',' '/' [','[(vararglist_no_posonly)]] | (vararglist_no_posonly)
59 #
60 # It needs to be fully expanded to allow our LL(1) parser to work on it.
61
62 varargslist: vfpdef ['=' test ](',' vfpdef ['=' test])* ',' '/' [',' [
63                      ((vfpdef ['=' test] ',')* ('*' [vname] (',' vname ['=' test])*
64                             [',' ['**' vname [',']]] | '**' vname [','])
65                             | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
66                      ]] | ((vfpdef ['=' test] ',')*
67                      ('*' [vname] (',' vname ['=' test])*  [',' ['**' vname [',']]]| '**' vname [','])
68                      | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
69
70 vname: NAME
71 vfpdef: vname | '(' vfplist ')'
72 vfplist: vfpdef (',' vfpdef)* [',']
73
74 stmt: simple_stmt | compound_stmt
75 simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
76 small_stmt: (expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt |
77              import_stmt | global_stmt | exec_stmt | assert_stmt)
78 expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
79                      ('=' (yield_expr|testlist_star_expr))*)
80 annassign: ':' test ['=' (yield_expr|testlist_star_expr)]
81 testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
82 augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
83             '<<=' | '>>=' | '**=' | '//=')
84 # For normal and annotated assignments, additional restrictions enforced by the interpreter
85 print_stmt: 'print' ( [ test (',' test)* [','] ] |
86                       '>>' test [ (',' test)+ [','] ] )
87 del_stmt: 'del' exprlist
88 pass_stmt: 'pass'
89 flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
90 break_stmt: 'break'
91 continue_stmt: 'continue'
92 return_stmt: 'return' [testlist_star_expr]
93 yield_stmt: yield_expr
94 raise_stmt: 'raise' [test ['from' test | ',' test [',' test]]]
95 import_stmt: import_name | import_from
96 import_name: 'import' dotted_as_names
97 import_from: ('from' ('.'* dotted_name | '.'+)
98               'import' ('*' | '(' import_as_names ')' | import_as_names))
99 import_as_name: NAME ['as' NAME]
100 dotted_as_name: dotted_name ['as' NAME]
101 import_as_names: import_as_name (',' import_as_name)* [',']
102 dotted_as_names: dotted_as_name (',' dotted_as_name)*
103 dotted_name: NAME ('.' NAME)*
104 global_stmt: ('global' | 'nonlocal') NAME (',' NAME)*
105 exec_stmt: 'exec' expr ['in' test [',' test]]
106 assert_stmt: 'assert' test [',' test]
107
108 compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt
109 async_stmt: ASYNC (funcdef | with_stmt | for_stmt)
110 if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite]
111 while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite]
112 for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
113 try_stmt: ('try' ':' suite
114            ((except_clause ':' suite)+
115             ['else' ':' suite]
116             ['finally' ':' suite] |
117            'finally' ':' suite))
118 with_stmt: 'with' with_item (',' with_item)*  ':' suite
119 with_item: test ['as' expr]
120 with_var: 'as' expr
121 # NB compile.c makes sure that the default except clause is last
122 except_clause: 'except' [test [(',' | 'as') test]]
123 suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
124
125 # Backward compatibility cruft to support:
126 # [ x for x in lambda: True, lambda: False if x() ]
127 # even while also allowing:
128 # lambda x: 5 if x else 2
129 # (But not a mix of the two)
130 testlist_safe: old_test [(',' old_test)+ [',']]
131 old_test: or_test | old_lambdef
132 old_lambdef: 'lambda' [varargslist] ':' old_test
133
134 namedexpr_test: test [':=' test]
135 test: or_test ['if' or_test 'else' test] | lambdef
136 or_test: and_test ('or' and_test)*
137 and_test: not_test ('and' not_test)*
138 not_test: 'not' not_test | comparison
139 comparison: expr (comp_op expr)*
140 comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
141 star_expr: '*' expr
142 expr: xor_expr ('|' xor_expr)*
143 xor_expr: and_expr ('^' and_expr)*
144 and_expr: shift_expr ('&' shift_expr)*
145 shift_expr: arith_expr (('<<'|'>>') arith_expr)*
146 arith_expr: term (('+'|'-') term)*
147 term: factor (('*'|'@'|'/'|'%'|'//') factor)*
148 factor: ('+'|'-'|'~') factor | power
149 power: [AWAIT] atom trailer* ['**' factor]
150 atom: ('(' [yield_expr|testlist_gexp] ')' |
151        '[' [listmaker] ']' |
152        '{' [dictsetmaker] '}' |
153        '`' testlist1 '`' |
154        NAME | NUMBER | STRING+ | '.' '.' '.')
155 listmaker: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] )
156 testlist_gexp: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] )
157 lambdef: 'lambda' [varargslist] ':' test
158 trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
159 subscriptlist: subscript (',' subscript)* [',']
160 subscript: test [':=' test] | [test] ':' [test] [sliceop]
161 sliceop: ':' [test]
162 exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']
163 testlist: test (',' test)* [',']
164 dictsetmaker: ( ((test ':' test | '**' expr)
165                  (comp_for | (',' (test ':' test | '**' expr))* [','])) |
166                 ((test [':=' test] | star_expr)
167                  (comp_for | (',' (test [':=' test] | star_expr))* [','])) )
168
169 classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
170
171 arglist: argument (',' argument)* [',']
172
173 # "test '=' test" is really "keyword '=' test", but we have no such token.
174 # These need to be in a single rule to avoid grammar that is ambiguous
175 # to our LL(1) parser. Even though 'test' includes '*expr' in star_expr,
176 # we explicitly match '*' here, too, to give it proper precedence.
177 # Illegal combinations and orderings are blocked in ast.c:
178 # multiple (test comp_for) arguments are blocked; keyword unpackings
179 # that precede iterable unpackings are blocked; etc.
180 argument: ( test [comp_for] |
181             test ':=' test |
182             test '=' test |
183             '**' test |
184             '*' test )
185
186 comp_iter: comp_for | comp_if
187 comp_for: [ASYNC] 'for' exprlist 'in' or_test [comp_iter]
188 comp_if: 'if' old_test [comp_iter]
189
190 # As noted above, testlist_safe extends the syntax allowed in list
191 # comprehensions and generators. We can't use it indiscriminately in all
192 # derivations using a comp_for-like pattern because the testlist_safe derivation
193 # contains comma which clashes with trailing comma in arglist.
194 #
195 # This was an issue because the parser would not follow the correct derivation
196 # when parsing syntactically valid Python code. Since testlist_safe was created
197 # specifically to handle list comprehensions and generator expressions enclosed
198 # with parentheses, it's safe to only use it in those. That avoids the issue; we
199 # can parse code like set(x for x in [],).
200 #
201 # The syntax supported by this set of rules is not a valid Python 3 syntax,
202 # hence the prefix "old".
203 #
204 # See https://bugs.python.org/issue27494
205 old_comp_iter: old_comp_for | old_comp_if
206 old_comp_for: [ASYNC] 'for' exprlist 'in' testlist_safe [old_comp_iter]
207 old_comp_if: 'if' old_test [old_comp_iter]
208
209 testlist1: test (',' test)*
210
211 # not used in grammar, but may appear in "node" passed from Parser to Compiler
212 encoding_decl: NAME
213
214 yield_expr: 'yield' [yield_arg]
215 yield_arg: 'from' test | testlist_star_expr