lex literal `fn `use `let `mut `if `else `struct literal `loop `while `for `in literal `true `false literal `ref `match `as `impl literal `self `return `type literal `pub `const `unsafe `mod literal `crate `$crate `super `macro_rules literal `where `extern `dyn `trait `enum `static literal `continue `break `move literal `; `:: `( `) `{ `} `. `, `@ literal `[ `] `: literal `-> `=> literal `< `> literal `? literal `- `+ `/ `* `% `! literal `# literal `^ `| `& literal `<< literal `== `!= `>= `<= literal `|| `&& literal `.. `..= `... literal `= literal `+= `-= `*= `/= `%= `&= `|= `^= `<<= `>>= literal `_ token id / [A-Za-z_] [A-Za-z_0-9]* / token string / 'b'? '"' ( [^\"] | '\\' any )* '"' / token char / 'b'? "'" ( [^\'] | '\\' any ) "'" / token lifetime / "'" id / token number / ( [0-9] [_0-9]* | '0x' [_a-fA-F0-9]+ | '0b' [_0-1]+ | '0o' [_0-7]+ ) ( ( 'u' | 'i' ) [a-z0-9]+ )? / token float/ [0-9]+ '.' [0-9]+ ( 'f32' | 'f64' )? / token raw_string / 'r"' ( any* :>> '"' ) | 'r#"' ( any* :>> '"#' ) | 'r##"' ( any* :>> '"##' ) | 'r###"' ( any* :>> '"###' ) | 'r####"' ( any* :>> '"####' ) | 'r#####"' ( any* :>> '"#####' ) / ignore / "//" [^\n]* '\n' / ignore / "/*" any* :>> "*/" / ignore / [ \t\n]+ / end namespace attr lex token id / [A-Za-z_] [A-Za-z_0-9]* / token string / '"' ( [^\"] | '\\' any )* '"' / token char / "'" ( [^\'] | '\\' any ) "'" / token lifetime / "'" id / token number / [0-9]+ / token float / [0-9]+ '.' [0-9]+ / literal `[ `] ignore / "//" [^\n]* '\n' / ignore / "/*" any* :>> "*/" / ignore / [ \t\n]+ / token sym / any / end def item [id] | [string] | [char] | [lifetime] | [number] | [float] | [sym] | [_list] def _list [ `[ item* `] ] end def attribute [`# `! attr::_list] | [`# attr::_list] namespace macro lex token id / [A-Za-z_] [A-Za-z_0-9]* / token string / '"' ( [^\"] | '\\' any )* '"' / token char / "'" ( [^\'] | '\\' any ) "'" / token lifetime / "'" id / token number / [0-9]+ / token float / [0-9]+ '.' [0-9]+ / literal `( `) `[ `] `{ `} `; ignore / "//" [^\n]* '\n' / ignore / "/*" any* :>> "*/" / ignore / [ \t\n]+ / token sym / any / end def item [id] | [string] | [char] | [lifetime] | [number] | [float] | [sym] | [macro] | [`;] def macro_semi [ `( item* `) `; ] | [ `[ item* `] `; ] | [ `{ item* `} ] def macro [ `( item* `) ] | [ `[ item* `] ] | [ `{ item* `} ] end def macro_invocation [simple_path `! macro::macro] def macro_invocation_semi [simple_path `! macro::macro_semi] # # Macro Defition # def macro_matcher [macro::macro] def macro_transcriber [macro::macro] def macro_rule [macro_matcher `=> macro_transcriber] def macro_rules_tail [macro_rules_tail `; macro_rule] | [] def opt_semi [`;] | [] def macro_rules [macro_rule macro_rules_tail opt_semi] def macro_rules_def [`( macro_rules `) `;] | [`[ macro_rules `] `;] | [`{ macro_rules `}] def macro_rules_definition [`macro_rules `! id macro_rules_def] # # Use statments # def simple_path_segment [id] | [`super] | [`self] | [`crate] | [`$crate] def sp_tail [sp_tail `:: simple_path_segment] | [] def simple_path [opt_sep simple_path_segment sp_tail] def use_list_tail [use_list_tail `, use_tree] | [] def use_path_opt [simple_path `::] | [`::] | [] def use_as_opt [`as id] | [`as `_] | [] def use_tree [use_path_opt `*] | [use_path_opt `{ use_tree use_list_tail opt_comma `}] | [simple_path use_as_opt] def use_declaration [`use use_tree `;] # # Patterns # def literal_pattern [`true] | [`false] | [char] | [string] | [raw_string] | [`- ? number] | [`- ? float] def identifier_pattern [opt_ref opt_mut id] | [opt_ref opt_mut id `@ pattern] def wildcard_pattern [`_] def range_pattern_bound [literal_pattern] def range_pattern [range_pattern_bound `..= range_pattern_bound] | [range_pattern_bound `... range_pattern_bound] def reference_pattern [`& opt_mut pattern] | [`&& opt_mut pattern] # # struct pattern # def struct_pattern_field [number `: pattern] | [id `: pattern] | [opt_ref opt_mut id] def struct_pattern_fields [struct_pattern_fields `, struct_pattern_field] | [struct_pattern_field] def struct_pattern_et_cetera [`..] def struct_pattern_elements [struct_pattern_fields] | [struct_pattern_fields `, ] | [struct_pattern_fields `, struct_pattern_et_cetera] | [struct_pattern_et_cetera] def opt_struct_pattern_elements [struct_pattern_elements] | [] def struct_pattern [path_in_expression `{ opt_struct_pattern_elements `}] def opt_comma [`,] | [] def tuple_struct_item [pattern] | [`..] def tuple_struct_items [tuple_struct_items `, tuple_struct_item] | [tuple_struct_item] def tuple_struct_pattern [path_in_expression `( tuple_struct_items opt_comma `)] def tuple_pattern_item [pattern] | [`..] def tuple_pattern_items [tuple_pattern_items `, tuple_pattern_item] | [tuple_pattern_item] def tuple_pattern [`( `)] | [`( tuple_pattern_item `, `)] | [`( tuple_pattern_item `, tuple_pattern_items opt_comma `)] def grouped_pattern [`( pattern `)] def pattern_list [pattern_list `, pattern] | [pattern] # # Grammar doesnt seem to support empty slice patterns, but found some code # allowing it. # def slice_pattern [`[ pattern `, pattern_list opt_comma `]] | [`[ pattern `, `]] | [`[ pattern `]] | [`[ `]] def path_pattern [path_in_expression] | [qualified_path_in_expression] def pattern [literal_pattern] | [identifier_pattern] | [wildcard_pattern] | [range_pattern] | [reference_pattern] | [struct_pattern] | [tuple_struct_pattern] | [tuple_pattern] | [grouped_pattern] | [slice_pattern] | [path_pattern] # Range Pattern # # Match Expressions. # def match_expression [`match expression `{ match_arms? `}] def match_arms_last [match_arm `=> block_expression `, ?] | [match_arm `=> expression `, ?] def match_arms_first_case [match_arm `=> block_expression `, ?] | [match_arm `=> expression `,] def match_arms_first_list [match_arms_first_list match_arms_first_case] | [] def match_arms [match_arms_first_list match_arms_last] def match_arm [match_arm_patterns opt_match_arm_guard] def match_arms_pattern_tail [match_arms_pattern_tail `| pattern] | [] def opt_bar [`|] | [] def match_arm_patterns [opt_bar pattern match_arms_pattern_tail] def opt_match_arm_guard [`if expression] | [] # # Return expressions # def return_expression [`return expression] | [`return] # # Break expression # def break_expression [`break expression] | [`break lifetime expression] | [`break lifetime] | [`break] # # Continue expression # def continue_expression [`continue lifetime] | [`continue] # # Generic Args # def lifetime_tail [lifetime_tail `, lifetime] | [] def lifetime_list [lifetime lifetime_tail] def opt_type_params [`< lifetime_list opt_comma `>] | [`< type_list opt_comma `>] | [`< lifetime_list `, type_list opt_comma `>] | [] # # Function declaration # def opt_return [] | [ `-> type] def extern_abi [`extern string] def function_qualifiers [`const ? `unsafe ? extern_abi?] def function_param [pattern `: type] def func_param_tail [func_param_tail `, function_param] | [] def function_parameters [function_param func_param_tail opt_comma] def function [ function_qualifiers `fn id opt_generics `( function_parameters? `) opt_return opt_where_clause block_expression ] # # Method declaration # def self_param [opt_mut `self] | [`& opt_mut `self] | [`& lifetime opt_mut `self] | [opt_mut `self `: type] def opt_method_params [`, function_parameters] | [`,] | [] def method [ function_qualifiers `fn id opt_generics `( self_param opt_method_params `) opt_return opt_where_clause block_expression ] # # Types # def qual_tail [qual_tail `:: id] | [] def qual_id [id qual_tail] def type_id [id opt_type_params] def type_path_segment [path_ident_segment `:: ? generic_args] | [path_ident_segment `:: ? type_path_fn] | [path_ident_segment `:: ?] def type_path_fn [`( type_path_fn_inputs? `) opt_arrow_type] def opt_arrow_type [`-> type] | [] def type_path_fn_inputs [type_list opt_comma] def type_path_tail [type_path_tail `:: type_path_segment] | [] def opt_sep [`::] | [] def type_path [opt_sep type_path_segment type_path_tail] def opt_lifetime [lifetime] | [] def array_type [`[ type `; expression `]] def slice_type [`[ type `]] def raw_pointer_type [`* `mut type_no_bounds] | [`* `const type_no_bounds] def tuple_type [`( `)] | [`( type `, `)] | [`( type `, type_list opt_comma `)] def trait_object_type [`dyn ? type_param_bounds] def impl_trait_type [`impl type_param_bounds] def impl_trait_type_one_bound [`impl trait_bound] def qualified_path_type [`< type `as type_path `>] | [`< type `>] def type_path_segment_list [] def qualified_path_in_type [qualified_path_type type_path_tail] # # Bare Function Type # def bare_function_return_type [`-> type_no_bounds] def function_parameters_maybe_named_variadic [maybe_named_function_parameters] | [maybe_named_function_parameters_variadic] def maybe_named_param_tail [maybe_named_param_tail `, maybe_named_param] | [] def maybe_named_function_parameters [maybe_named_param maybe_named_param_tail `, ?] def maybe_named_param [id `: type] | [`_ `: type] | [type] def maybe_named_function_parameters_variadic [maybe_named_param maybe_named_param_tail `, `...] def bare_function_type [ for_lifetimes? function_qualifiers `fn `( function_parameters_maybe_named_variadic? `) bare_function_return_type? ] # # Type # def type [type_no_bounds] | [impl_trait_type] | [trait_object_type] def type_no_bounds [impl_trait_type_one_bound] | [type_path] | [array_type] | [slice_type] | [raw_pointer_type] | [`& opt_lifetime type] | [`& `mut type] | [`& lifetime `mut type] | [tuple_type] | [`_] | [`!] | [qualified_path_in_type] | [bare_function_type] def type_list [type_list `, type] | [type] def opt_mut [`mut] | [] def opt_ref [`ref] | [] def opt_type [`: type] | [] def let_rvalue [expression] | [`{ statements `}] def expr_tail [expr_tail `, expression] | [] def expr_list [expression expr_tail] | [] def _construct [attribute* id] | [attribute* id `: expression] def cons_plus [cons_plus `, _construct] | [_construct] def cons_list [cons_plus opt_comma] | [] # # Expression # def path_ident_segment [id] | [`self] | [`crate] | [`super] def path_expr_segment [path_ident_segment] | [path_ident_segment `:: generic_args] def generic_args [`< `>] | [`< generic_args_lifetimes opt_comma `>] | [`< generic_args_types opt_comma `>] | [`< generic_args_bindings opt_comma `>] | [`< generic_args_types `, generic_args_bindings opt_comma `>] | [`< generic_args_lifetimes `, generic_args_types opt_comma `>] | [`< generic_args_lifetimes `, generic_args_bindings opt_comma `>] | [`< generic_args_lifetimes `, generic_args_types `, generic_args_bindings opt_comma `>] def generic_args_lifetimes [lifetime_list] def generic_args_types [type_list] def generic_args_binding [id `= type] def generic_args_bindings [generic_args_bindings `, generic_args_binding] | [generic_args_binding] def pie_tail [pie_tail `:: path_expr_segment] | [] def opt_path_sep [`::] | [] def path_in_expression [opt_path_sep path_expr_segment pie_tail] def qualified_path_in_expression [qualified_path_type type_path_tail] def path_expression [path_in_expression] | [qualified_path_in_expression] def tuple_expression [`( expression `, `)] | [`( expression `, expr_list opt_comma `)] def array_expression [`[ expr_list opt_comma `]] | [`[ expression `; expression `]] def closure_parameters [closure_parameters `, closure_param] | [closure_param] def closure_param [pattern] | [pattern `: type] def closure_expression_param_forms [`| closure_parameters opt_comma `|] | [`||] def closure_expression [`move ? closure_expression_param_forms expression] | [`move ? closure_expression_param_forms `-> type_no_bounds block_expression] def paths [path_expression] | [char] | [string] | [raw_string] | [number] | [float] | [path_in_expression `{ cons_list `}] | [path_in_expression `{ `.. expression `}] | [path_in_expression `{ cons_list `, `.. expression `}] | [`( `)] | [`true] | [`false] | [`( expression `)] | [tuple_expression] | [array_expression] | [macro_invocation] | [closure_expression] | [block_expression] | [match_expression] | [if_expression] | [if_let_expression] def func_index [func_index `. path_expr_segment `( expr_list opt_comma `)] | [func_index `. id] | [func_index `. number] | [func_index `( expr_list opt_comma `)] | [func_index `[ expr_list opt_comma `]] | [func_index `?] | [paths] def question [func_index] def unary [question] | [`- unary] | [`* unary] | [`! unary] | [`& unary] | [`& `mut unary] | [`mut unary] def as [as `as type_no_bounds] | [unary] def mult [mult `* as] | [mult `/ as] | [mult `% as] | [as] def add_sub [add_sub `- mult] | [add_sub `+ mult] | [mult] def shift [shift `> `> add_sub] | [shift `<< add_sub] | [add_sub] def bitwise_and [bitwise_and `& shift] | [shift] def bitwise_xor [bitwise_xor `^ bitwise_and] | [bitwise_and] def bitwise_or [bitwise_or `| bitwise_xor] | [bitwise_xor] def comp_op [`==] | [`!=] | [`>] | [`<] | [`>=] | [`<=] def comparison [comparison comp_op bitwise_or] | [bitwise_or] def lazy_conjunction [lazy_conjunction `&& comparison] | [comparison] def lazy_disjunction [lazy_disjunction `|| lazy_conjunction] | [lazy_conjunction] def range_expression [range_expression `.. lazy_disjunction] | [lazy_disjunction `..] | [`.. lazy_disjunction] | [`..] | [range_expression `..= lazy_disjunction] | [`..= lazy_disjunction] | [lazy_disjunction] # Evaluates right to left. def assignment_expression [range_expression `= expression] | [range_expression] def compound_op [`+=] | [`-=] | [`*=] | [`/=] | [`%=] | [`&=] | [`|=] | [`^=] | [`<<=] | [`>>=] # Evaluates right to left. def compound_expression [assignment_expression compound_op compound_expression] | [assignment_expression] def expression [expression_without_block] | [expression_with_block] # # Statements # def block_expression [`unsafe ? `{ statements? `}] def let_statement [`let pattern opt_type `= let_rvalue `;] | [`let pattern opt_type `;] def expression_without_block [compound_expression `? ?] | [return_expression] | [break_expression] | [continue_expression] def expression_with_block [block_expression] | [loop_expression] | [if_expression] | [if_let_expression] | [match_expression] def expression_statement [expression_without_block `;] | [expression_with_block] def statement [`;] | [item] | [let_statement] | [expression_statement] | [use_declaration] | [macro_invocation_semi] def statements [statement+] | [statement+ expression_without_block] | [expression_without_block] def loop_label [lifetime `:] def loop_expression [loop_label? `loop block_expression] | [loop_label? `while expression block_expression] | [loop_label? `while `let match_arm_patterns `= expression block_expression] | [loop_label? `for pattern `in expression block_expression] def if_expression [`if expression block_expression opt_else_expression] def opt_else_expression [`else block_expression] | [`else if_expression] | [`else if_let_expression] | [] def if_let_expression [ `if `let match_arm_patterns `= expression block_expression opt_else_expression ] def visibility [`pub] | [`pub `( `crate `)] | [`pub `( `self `)] | [`pub `( `super `)] | [`pub `( `in simple_path `)] def field [attribute* visibility? id `: type] def field_plus [field_plus `, field] | [field] def field_list [field_plus] | [] # # Lifetime Params # def colon_lifetime_bounds [`: lifetime_bounds] def lifetime_param [lifetime colon_lifetime_bounds?] def lifetime_param_list [lifetime_param_list `, lifetime_param ] | [lifetime_param] # # Type param bounds # def trait_bound [`? ? for_lifetimes? type_path] | [`( `? ? for_lifetimes? type_path `)] def type_param_bound [lifetime] | [trait_bound] def opt_plus [`+] | [] def tpb_tail [`+ type_param_bound] def type_param_bounds [type_param_bound tpb_tail* opt_plus] # # Type Params # def opt_eq_type [`= type] | [] def opt_type_param_bounds [`: type_param_bounds] | [] def type_param [id opt_type_param_bounds opt_eq_type] def type_param_tail [type_param_tail `, type_param] | [] def type_param_list [type_param type_param_tail] # # Generics # def generic_params [lifetime_param_list `, type_param_list] | [lifetime_param_list] | [type_param_list] | [] def opt_generics [`< generic_params `>] | [] # # Where clause # def lifetime_params [lifetime_param_list? opt_comma] def for_lifetimes [`for `< lifetime_params `>] def lifetime_bounds_list [lifetime_bounds_list `+ lifetime] | [lifetime] def lifetime_bounds [lifetime_bounds_list? opt_plus] def lifetime_where_clause_item [lifetime `: lifetime_bounds] def type_bound_where_clause_item [for_lifetimes? type `: type_param_bounds?] def where_clause_item [lifetime_where_clause_item] | [type_bound_where_clause_item] def where_clause_item_list [where_clause_item_list `, where_clause_item] | [where_clause_item] def opt_where_clause [`where where_clause_item_list opt_comma ] | [] # # Tuple List # def tuple_field [attribute* visibility? type] def tuple_field_list [tuple_field_list `, tuple_field] | [tuple_field] def tuple_fields [tuple_field_list opt_comma] # # Structure # def struct_field [attribute* visibility? id `: type] def struct_field_list [struct_field_list `, struct_field] | [struct_field] def struct_fields [struct_field_list opt_comma] def struct_struct [`struct id opt_generics opt_where_clause `{ struct_fields? `}] | [`struct id opt_generics opt_where_clause `;] def tuple_struct [`struct id opt_generics `( tuple_fields? `) opt_where_clause `; ] def structure [struct_struct] | [tuple_struct] # # Union # def union [Union: id id opt_generics opt_where_clause `{ struct_fields? `}] { if $lhs.Union != "union" reject } # # Trait # def opt_type_param_bounds_opt [`: type_param_bounds?] | [] def trait [ `trait id opt_generics opt_type_param_bounds_opt opt_where_clause `{ trait_item* `} ] def trait_item [attribute* trait_func] | [attribute* trait_method] | [attribute* trait_const] | [attribute* trait_type] | [attribute* macro_invocation_semi] def trait_func [trait_func_decl `;] | [trait_func_decl block_expression] def trait_method [trait_method_decl `;] | [trait_method_decl block_expression] def trait_func_decl [function_qualifiers `fn id opt_generics `( trait_function_parameters `) opt_return opt_where_clause] def trait_method_decl [function_qualifiers `fn id opt_generics `( self_param trait_method_parameters `) opt_return opt_where_clause] def trait_function_parameters [trait_param_list `,] | [trait_param_list ] | [] def trait_method_parameters [`, trait_param_list `,] | [`, trait_param_list ] | [`,] | [] def trait_param_list [trait_param_list `, trait_function_param] | [trait_function_param] def trait_function_param [pattern `: type] | [type] def trait_const [`const id `: type `;] | [`const id `: type `= expression `;] def trait_type [`type id opt_type_param_bounds_opt `;] # # Implementation # def inherent_impl_item [attribute* visibility? function] commit | [attribute* visibility? method] commit def inherent_impl [`impl opt_generics type opt_where_clause `{ inherent_impl_item* `}] def trait_impl_item [attribute* visibility? type_alias] | [attribute* visibility? constant_item] | [attribute* visibility? function] | [attribute* visibility? method] def constant_item [`const id `: type `= expression `;] | [`const `_ `: type `= expression `;] def trait_impl [`unsafe ? `impl opt_generics `! ? type_path `for type opt_where_clause `{ trait_impl_item* `}] def implementation [inherent_impl] | [trait_impl] def type_alias [`type id opt_generics opt_where_clause `= type `;] def const_item [`const id `: type `= expression `;] | [`const `_ `: type `= expression `;] def module [`mod id `;] | [`mod id `{ item* `}] def crate_ref [id] | [`self] def as_clause [`as id] | [`as `_] def extern_crate [`extern `crate crate_ref as_clause? `;] def enum [`enum id opt_generics opt_where_clause `{ enum_items? opt_comma `}] def enum_items [enum_items `, enum_item] | [enum_item] def enum_item [attribute* id enum_item_tuple] | [attribute* id enum_item_struct] | [attribute* id enum_item_discriminant] | [attribute* id] def enum_item_tuple [`( tuple_fields? `)] def enum_item_struct [`{ field_list opt_comma `}] def enum_item_discriminant [`= expression] def static_item [`static opt_mut? id `: type `= expression `;] def abi [string] | [raw_string] def external_static_item [`static `mut ? id `: type `;] def function_return_type [`-> type] def external_function_item [`fn id opt_generics `( named_function_parameters? `) function_return_type? opt_where_clause `;] def named_function_param [id `: type] | [`_ `: type] def named_function_parameters [named_function_parameter_list `, `...] | [named_function_parameter_list `,] | [named_function_parameter_list ] def named_function_parameter_list [named_function_parameter_list `, named_function_param] | [named_function_param] def external_item [attribute* visibility? external_static_item] | [attribute* visibility? external_function_item] def extern_block [`extern abi? `{ external_item* `}] # # All Items. # def item [visibility? vis_item] commit | [macro_invocation_semi] commit | [macro_rules_definition] commit def vis_item [attribute] commit | [function] commit | [structure] commit | [union] commit | [trait] commit | [implementation] commit | [use_declaration] commit | [type_alias] commit | [const_item] commit | [static_item] commit | [module] commit | [extern_crate] commit | [extern_block] commit | [enum] commit def program [item*]