tree-sitter-python.ebnf

//
// From tree-sitter-python/src/grammar.json
//
//
// EBNF to generate railroad diagram at 
//      (IPV6) https://www.bottlecaps.de/rr/ui
//      (IPV4) https://rr.red-dove.com/ui
//

module ::=
	 _statement*

_statement ::=
	 _simple_statements
	| _compound_statement

_simple_statements ::=
	 _simple_statement ( ';' _simple_statement )* ';'? _newline

_simple_statement ::=
	 future_import_statement
	| import_statement
	| import_from_statement
	| print_statement
	| assert_statement
	| expression_statement
	| return_statement
	| delete_statement
	| raise_statement
	| pass_statement
	| break_statement
	| continue_statement
	| global_statement
	| nonlocal_statement
	| exec_statement
	| type_alias_statement

import_statement ::=
	 'import' _import_list

import_prefix ::=
	 '.'+

relative_import ::=
	 import_prefix dotted_name?

future_import_statement ::=
	 'from' '__future__' 'import' ( _import_list | '(' _import_list ')' )

import_from_statement ::=
	 'from' ( relative_import | dotted_name ) 'import' ( wildcard_import | _import_list | '(' _import_list ')' )

_import_list ::=
	 ( dotted_name | aliased_import ) ( ',' ( dotted_name | aliased_import ) )* ','?

aliased_import ::=
	 dotted_name 'as' identifier

wildcard_import ::=
	 '*'

print_statement ::=
	 'print' chevron ( ',' expression )* ','?
	| 'print' expression ( ',' expression )* ','?

chevron ::=
	 '>>' expression

assert_statement ::=
	 'assert' expression ( ',' expression )*

expression_statement ::=
	 expression
	| expression ( ',' expression )* ','?
	| assignment
	| augmented_assignment
	| yield

named_expression ::=
	 _named_expression_lhs ':=' expression

_named_expression_lhs ::=
	 identifier
	| keyword_identifier

return_statement ::=
	 'return' _expressions?

delete_statement ::=
	 'del' _expressions

_expressions ::=
	 expression
	| expression_list

raise_statement ::=
	 'raise' _expressions? ( 'from' expression )?

pass_statement ::=
	 'pass'

break_statement ::=
	 'break'

continue_statement ::=
	 'continue'

_compound_statement ::=
	 if_statement
	| for_statement
	| while_statement
	| try_statement
	| with_statement
	| function_definition
	| class_definition
	| decorated_definition
	| match_statement

if_statement ::=
	 'if' expression ':' _suite elif_clause* else_clause?

elif_clause ::=
	 'elif' expression ':' _suite

else_clause ::=
	 'else' ':' _suite

match_statement ::=
	 'match' expression ( ',' expression )* ','? ':' _match_block

_match_block ::=
	 _indent case_clause* _dedent
	| _newline

case_clause ::=
	 'case' case_pattern ( ',' case_pattern )* ','? if_clause? ':' _suite

for_statement ::=
	 'async'? 'for' _left_hand_side 'in' _expressions ':' _suite else_clause?

while_statement ::=
	 'while' expression ':' _suite else_clause?

try_statement ::=
	 'try' ':' _suite ( except_clause+ else_clause? finally_clause? | except_group_clause+ else_clause? finally_clause? | finally_clause )

except_clause ::=
	 'except' ( expression ( ( 'as' | ',' ) expression )? )? ':' _suite

except_group_clause ::=
	 'except*' expression ( 'as' expression )? ':' _suite

finally_clause ::=
	 'finally' ':' _suite

with_statement ::=
	 'async'? 'with' with_clause ':' _suite

with_clause ::=
	 with_item ( ',' with_item )* ','?
	| '(' with_item ( ',' with_item )* ','? ')'

with_item ::=
	 expression

function_definition ::=
	 'async'? 'def' identifier type_parameter? parameters ( '->' type )? ':' _suite

parameters ::=
	 '(' _parameters? ')'

lambda_parameters ::=
	 _parameters

list_splat ::=
	 '*' expression

dictionary_splat ::=
	 '**' expression

global_statement ::=
	 'global' identifier ( ',' identifier )*

nonlocal_statement ::=
	 'nonlocal' identifier ( ',' identifier )*

exec_statement ::=
	 'exec' ( string | identifier ) ( 'in' expression ( ',' expression )* )?

type_alias_statement ::=
	 'type' type '=' type

class_definition ::=
	 'class' identifier type_parameter? argument_list? ':' _suite

type_parameter ::=
	 '[' type ( ',' type )* ']'

parenthesized_list_splat ::=
	 '(' ( parenthesized_list_splat | list_splat ) ')'

argument_list ::=
	 '(' ( ( expression | list_splat | dictionary_splat | parenthesized_list_splat | keyword_argument ) ( ',' ( expression | list_splat | dictionary_splat | parenthesized_list_splat | keyword_argument ) )* )? ','? ')'

decorated_definition ::=
	 decorator+ ( class_definition | function_definition )

decorator ::=
	 '@' expression _newline

_suite ::=
	 _simple_statements
	| _indent block
	| _newline

block ::=
	 _statement* _dedent

expression_list ::=
	 expression ( ',' | ( ',' expression )+ ','? )

dotted_name ::=
	 identifier ( '.' identifier )*

case_pattern ::=
	 _as_pattern | keyword_pattern | _simple_pattern

_simple_pattern ::=
	 class_pattern | splat_pattern | union_pattern | _list_pattern | _tuple_pattern | dict_pattern | string | concatenated_string | true | false | none | '-'? ( integer | float ) | complex_pattern | dotted_name | '_'

_as_pattern ::=
	 case_pattern 'as' identifier

union_pattern ::=
	 _simple_pattern '|' _simple_pattern+

_list_pattern ::=
	 '[' ( case_pattern ( ',' case_pattern )* ','? )? ']'

_tuple_pattern ::=
	 '(' ( case_pattern ( ',' case_pattern )* ','? )? ')'

dict_pattern ::=
	 '{' ( ( _key_value_pattern | splat_pattern ) ( ',' ( _key_value_pattern | splat_pattern ) )* ','? )? '}'

_key_value_pattern ::=
	 _simple_pattern ':' case_pattern

keyword_pattern ::=
	 identifier '=' _simple_pattern

splat_pattern ::=
	 ( '*' | '**' ) ( identifier | '_' )

class_pattern ::=
	 dotted_name '(' ( case_pattern ( ',' case_pattern )* ','? )? ')'

complex_pattern ::=
	 '-'? ( integer | float ) ( '+' | '-' ) ( integer | float )

_parameters ::=
	 parameter ( ',' parameter )* ','?

_patterns ::=
	 pattern ( ',' pattern )* ','?

parameter ::=
	 identifier
	| typed_parameter
	| default_parameter
	| typed_default_parameter
	| list_splat_pattern
	| tuple_pattern
	| keyword_separator
	| positional_separator
	| dictionary_splat_pattern

pattern ::=
	 identifier
	| keyword_identifier
	| subscript
	| attribute
	| list_splat_pattern
	| tuple_pattern
	| list_pattern

tuple_pattern ::=
	 '(' _patterns? ')'

list_pattern ::=
	 '[' _patterns? ']'

default_parameter ::=
	 ( identifier | tuple_pattern ) '=' expression

typed_default_parameter ::=
	 identifier ':' type '=' expression

list_splat_pattern ::=
	 '*' ( identifier | keyword_identifier | subscript | attribute )

dictionary_splat_pattern ::=
	 '**' ( identifier | keyword_identifier | subscript | attribute )

as_pattern ::=
	 expression 'as' expression

_expression_within_for_in_clause ::=
	 expression
	| lambda_within_for_in_clause

expression ::=
	 comparison_operator
	| not_operator
	| boolean_operator
	| lambda
	| primary_expression
	| conditional_expression
	| named_expression
	| as_pattern

primary_expression ::=
	 await
	| binary_operator
	| identifier
	| keyword_identifier
	| string
	| concatenated_string
	| integer
	| float
	| true
	| false
	| none
	| unary_operator
	| attribute
	| subscript
	| call
	| list
	| list_comprehension
	| dictionary
	| dictionary_comprehension
	| set
	| set_comprehension
	| tuple
	| parenthesized_expression
	| generator_expression
	| ellipsis
	| list_splat_pattern

not_operator ::=
	 'not' expression

boolean_operator ::=
	 expression 'and' expression
	| expression 'or' expression

binary_operator ::=
	 primary_expression '+' primary_expression
	| primary_expression '-' primary_expression
	| primary_expression '*' primary_expression
	| primary_expression '@' primary_expression
	| primary_expression '/' primary_expression
	| primary_expression '%' primary_expression
	| primary_expression '//' primary_expression
	| primary_expression '**' primary_expression
	| primary_expression '|' primary_expression
	| primary_expression '&' primary_expression
	| primary_expression '^' primary_expression
	| primary_expression '<<' primary_expression
	| primary_expression '>>' primary_expression

unary_operator ::=
	 ( '+' | '-' | '~' ) primary_expression

comparison_operator ::=
	 primary_expression ( ( '<' | '<=' | '==' | '!=' | '>=' | '>' | '<>' | 'in' | ( 'not' 'in' ) | 'is' | ( 'is' 'not' ) ) primary_expression )+

lambda ::=
	 'lambda' lambda_parameters? ':' expression

lambda_within_for_in_clause ::=
	 'lambda' lambda_parameters? ':' _expression_within_for_in_clause

assignment ::=
	 _left_hand_side ( '=' _right_hand_side | ':' type | ':' type '=' _right_hand_side )

augmented_assignment ::=
	 _left_hand_side ( '+=' | '-=' | '*=' | '/=' | '@=' | '//=' | '%=' | '**=' | '>>=' | '<<=' | '&=' | '^=' | '|=' ) _right_hand_side

_left_hand_side ::=
	 pattern
	| pattern_list

pattern_list ::=
	 pattern ( ',' | ( ',' pattern )+ ','? )

_right_hand_side ::=
	 expression
	| expression_list
	| assignment
	| augmented_assignment
	| pattern_list
	| yield

yield ::=
	 'yield' ( 'from' expression | _expressions )

attribute ::=
	 primary_expression '.' identifier

subscript ::=
	 primary_expression '[' ( expression | slice ) ( ',' ( expression | slice ) )* ','? ']'

slice ::=
	 expression? ':' expression? ( ':' expression? )?

ellipsis ::=
	 '...'

call ::=
	 primary_expression ( generator_expression | argument_list )

typed_parameter ::=
	 ( identifier | list_splat_pattern | dictionary_splat_pattern ) ':' type

type ::=
	 expression
	| splat_type
	| generic_type
	| union_type
	| constrained_type
	| member_type

splat_type ::=
	 ( '*' | '**' ) identifier

generic_type ::=
	 identifier type_parameter

union_type ::=
	 type '|' type

constrained_type ::=
	 type ':' type

member_type ::=
	 type '.' identifier

keyword_argument ::=
	 ( identifier | keyword_identifier ) '=' expression

list ::=
	 '[' _collection_elements? ']'

set ::=
	 '{' _collection_elements '}'

tuple ::=
	 '(' _collection_elements? ')'

dictionary ::=
	 '{' ( ( pair | dictionary_splat ) ( ',' ( pair | dictionary_splat ) )* )? ','? '}'

pair ::=
	 expression ':' expression

list_comprehension ::=
	 '[' expression _comprehension_clauses ']'

dictionary_comprehension ::=
	 '{' pair _comprehension_clauses '}'

set_comprehension ::=
	 '{' expression _comprehension_clauses '}'

generator_expression ::=
	 '(' expression _comprehension_clauses ')'

_comprehension_clauses ::=
	 for_in_clause ( for_in_clause | if_clause )*

parenthesized_expression ::=
	 '(' ( expression | yield ) ')'

_collection_elements ::=
	 ( expression | yield | list_splat | parenthesized_list_splat ) ( ',' ( expression | yield | list_splat | parenthesized_list_splat ) )* ','?

for_in_clause ::=
	 'async'? 'for' _left_hand_side 'in' ( _expression_within_for_in_clause ( ',' _expression_within_for_in_clause )* ) ','?

if_clause ::=
	 'if' expression

conditional_expression ::=
	 expression 'if' expression 'else' expression

concatenated_string ::=
	 string string+

string ::=
	 string_start ( interpolation | string_content )* string_end

string_content ::=
	 ( escape_interpolation | escape_sequence | _not_escape_sequence | _string_content )+

interpolation ::=
	 '{' _f_expression '='? type_conversion? format_specifier? '}'

_f_expression ::=
	 expression
	| expression_list
	| pattern_list
	| yield

escape_sequence ::=
	 '\\'  ( 'u'[a-fA-F0-9]'{4}' | 'U'[a-fA-F0-9]'{8}' | 'x'[a-fA-F0-9]'{2}' | [0-9]'{3}' | '#x0D'?'#x0A' | ['"abfrntv\] | 'N\{'[^}]+'\}' )

_not_escape_sequence ::=
	 '\\' 

format_specifier ::=
	 ':' ( [^{}#x0A]+ | interpolation )*

type_conversion ::=
	 '!'[a-z]

integer ::=
	 ( ( '0x' | '0X' ) '_'?[A-Fa-f0-9]++ [Ll]? | ( '0o' | '0O' ) '_'?[0-7]++ [Ll]? | ( '0b' | '0B' ) '_'?[0-1]++ [Ll]? | [0-9]+'_'?+ ( [Ll] | [jJ] ) )

float ::=
	 ( ( [0-9]+'_'?+ '.' [0-9]+'_'?+? ( [eE][\+-]? [0-9]+'_'?+ )? | [0-9]+'_'?+? '.' [0-9]+'_'?+ ( [eE][\+-]? [0-9]+'_'?+ )? | [0-9]+'_'?+ [eE][\+-]? [0-9]+'_'?+ ) ( [Ll] | [jJ] )? )

identifier ::=
	 [_\p{XID_Start}][_\p{XID_Continue}]*

keyword_identifier ::=
	 ( 'print' | 'exec' | 'async' | 'await' | 'match' )
	| 'type'

true ::=
	 'True'

false ::=
	 'False'

none ::=
	 'None'

await ::=
	 'await' primary_expression

comment ::=
	 ( '#' '.'* )

line_continuation ::=
	 ( '\\'  ( '\r' ? '\n'  | '\0'  ) )

positional_separator ::=
	 '/'

keyword_separator ::=
	 '*'