Grammar Diff (vN vs vN+1)

	vN			vN+1
t	1	<<< =========================================================	t	1	<<< =========================================================
	2	Vitte — Active Frontend Grammar		2	Vitte — Active Frontend Grammar
	3	parser-aligned surface for docs/tests/frontend sync		3	parser-aligned surface for docs/tests/frontend sync
	4	canonical blocks: { }		4	canonical blocks: { }
	5	This file describes the syntax currently preserved by the		5	This file describes the syntax currently preserved by the
	6	active frontend AST builder. Ambitious future-only surfaces		6	active frontend AST builder. Ambitious future-only surfaces
	7	should not be specified here until they are actually built.		7	should not be specified here until they are actually built.
	8	========================================================= >>>		8	========================================================= >>>
	9			9
	10	program ::= WS? { toplevel WS? } EOF ;		10	program ::= WS? { toplevel WS? } EOF ;
	11			11
	12	<<< ================= Top-level ================= >>>		12	<<< ================= Top-level ================= >>>
	13			13
	14	toplevel ::= inner_attribute		14	toplevel ::= inner_attribute
	15	\| space_decl		15	\| space_decl
	16	\| use_decl		16	\| use_decl
	17	\| export_decl		17	\| export_decl
	18	\| const_decl		18	\| const_decl
	19	\| static_decl		19	\| static_decl
	20	\| region_decl		20	\| region_decl
	21	\| type_alias_decl		21	\| type_alias_decl
	22	\| opaque_type_decl		22	\| opaque_type_decl
	23	\| extern_type_decl		23	\| extern_type_decl
	24	\| form_decl		24	\| form_decl
	25	\| class_decl		25	\| class_decl
	26	\| union_decl		26	\| union_decl
	27	\| bits_decl		27	\| bits_decl
	28	\| pick_decl		28	\| pick_decl
	29	\| flags_decl		29	\| flags_decl
	30	\| trait_decl		30	\| trait_decl
	31	\| impl_decl		31	\| impl_decl
	32	\| extern_block		32	\| extern_block
	33	\| proc_decl		33	\| proc_decl
	34	\| intrinsic_decl		34	\| intrinsic_decl
	35	\| compiler_decl		35	\| compiler_decl
	36	\| query_decl		36	\| query_decl
	37	\| pass_decl		37	\| pass_decl
	38	\| backend_decl		38	\| backend_decl
	39	\| diagnostic_decl		39	\| diagnostic_decl
	40	\| macro_decl		40	\| macro_decl
	41	\| static_assert_decl		41	\| static_assert_decl
	42	\| test_decl		42	\| test_decl
	43	\| bench_decl		43	\| bench_decl
	44	\| entry_decl		44	\| entry_decl
	45	;		45	;
	46			46
	47	space_decl ::= "space" WS1 module_path ;		47	space_decl ::= "space" WS1 module_path ;
	48			48
	49	use_decl ::= "use" WS1 package_path [ use_group \| use_glob ] [ WS1 "as" WS1 ident ] ;		49	use_decl ::= "use" WS1 package_path [ use_group \| use_glob ] [ WS1 "as" WS1 ident ] ;
	50	use_glob ::= "." "*" ;		50	use_glob ::= "." "*" ;
	51	use_group ::= "." "{" WS? ( "" \| import_items [ WS? "," WS? "" ]? ) WS? "}" ;		51	use_group ::= "." "{" WS? ( "" \| import_items [ WS? "," WS? "" ]? ) WS? "}" ;
	52			52
	53	import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ;		53	import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ;
	54	import_item ::= ident [ WS1 "as" WS1 ident ] ;		54	import_item ::= ident [ WS1 "as" WS1 ident ] ;
	55			55
	56	export_decl ::= "export" WS1 ( "*" \| ident_list \| "{" WS? ident_list WS? "}" ) ;		56	export_decl ::= "export" WS1 ( "*" \| ident_list \| "{" WS? ident_list WS? "}" ) ;
	57			57
	58	const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		58	const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	59	static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		59	static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	60	region_decl ::= { attr_prefix WS? } "region" WS1 ident [ WS? ":" WS? region_kind ] [ WS? region_capabilities ] WS? meta_		60	region_decl ::= { attr_prefix WS? } "region" WS1 ident [ WS? ":" WS? region_kind ] [ WS? region_capabilities ] WS? meta_
	>	tail ;		>	tail ;
	61	region_kind ::= "stack" \| "heap" \| "arena" \| "static" \| "mmio" \| "dma" \| ident ;		61	region_kind ::= "stack" \| "heap" \| "arena" \| "static" \| "mmio" \| "dma" \| ident ;
	62	region_capabilities ::= "(" WS? ident_list? WS? ")" ;		62	region_capabilities ::= "(" WS? ident_list? WS? ")" ;
	63			63
	64	type_alias_decl ::= { attr_prefix WS? } "type" WS1 ident [ generic_params ] WS? "=" WS? type_expr ;		64	type_alias_decl ::= { attr_prefix WS? } "type" WS1 ident [ generic_params ] WS? "=" WS? type_expr ;
	65	opaque_type_decl ::= { attr_prefix WS? } "opaque" WS1 "type" WS1 ident [ generic_params ] [ WS? "=" WS? type_expr ] ;		65	opaque_type_decl ::= { attr_prefix WS? } "opaque" WS1 "type" WS1 ident [ generic_params ] [ WS? "=" WS? type_expr ] ;
	66	extern_type_decl ::= { attr_prefix WS? } "extern" WS1 "type" WS1 ident [ generic_params ] [ WS? ";" ] ;		66	extern_type_decl ::= { attr_prefix WS? } "extern" WS1 "type" WS1 ident [ generic_params ] [ WS? ";" ] ;
	67			67
	68	form_decl ::= { attr_prefix WS? } "form" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? form_items? WS? "		68	form_decl ::= { attr_prefix WS? } "form" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? form_items? WS? "
	>	}" ;		>	}" ;
	69	class_decl ::= { attr_prefix WS? } "class" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? class_items? WS		69	class_decl ::= { attr_prefix WS? } "class" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? class_items? WS
	>	? "}" ;		>	? "}" ;
	70	union_decl ::= { attr_prefix WS? } "union" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? field_list? WS?		70	union_decl ::= { attr_prefix WS? } "union" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? field_list? WS?
	>	"}" ;		>	"}" ;
	71			71
	72	form_items ::= form_item { WS? ","? WS? form_item } [ WS? "," ] ;		72	form_items ::= form_item { WS? ","? WS? form_item } [ WS? "," ] ;
	73	form_item ::= field_item \| const_decl \| type_alias_decl \| proc_decl ;		73	form_item ::= field_item \| const_decl \| type_alias_decl \| proc_decl ;
	74			74
	75	class_items ::= class_item { WS? ","? WS? class_item } [ WS? "," ] ;		75	class_items ::= class_item { WS? ","? WS? class_item } [ WS? "," ] ;
	76	class_item ::= field_item \| const_decl \| type_alias_decl \| proc_decl ;		76	class_item ::= field_item \| const_decl \| type_alias_decl \| proc_decl ;
	77			77
	78	field_list ::= field_item { WS? "," WS? field_item } [ WS? "," ] ;		78	field_list ::= field_item { WS? "," WS? field_item } [ WS? "," ] ;
	79	field_item ::= { attr_prefix WS? } [ visibility WS1 ] ident WS? ":" WS? type_expr [ WS? "=" WS? expr ] ;		79	field_item ::= { attr_prefix WS? } [ visibility WS1 ] ident WS? ":" WS? type_expr [ WS? "=" WS? expr ] ;
	80			80
	81	bits_decl ::= { attr_prefix WS? } "bits" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? bitfield_list? WS? "}" ;		81	bits_decl ::= { attr_prefix WS? } "bits" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? bitfield_list? WS? "}" ;
	82	bitfield_list ::= bitfield_item { WS? "," WS? bitfield_item } [ WS? "," ] ;		82	bitfield_list ::= bitfield_item { WS? "," WS? bitfield_item } [ WS? "," ] ;
	83	bitfield_item ::= ident WS? ":" WS? expr WS? ".." WS? expr ;		83	bitfield_item ::= ident WS? ":" WS? expr WS? ".." WS? expr ;
	84			84
	85	pick_decl ::= { attr_prefix WS? } "pick" WS1 ident [ generic_params ] [ WS? ":" WS? type_expr ] [ WS? where_clause ] WS?		85	pick_decl ::= { attr_prefix WS? } "pick" WS1 ident [ generic_params ] [ WS? ":" WS? type_expr ] [ WS? where_clause ] WS?
	>	"{" WS? case_list? WS? "}" ;		>	"{" WS? case_list? WS? "}" ;
	86	case_list ::= case_item { WS? "," WS? case_item } [ WS? "," ] ;		86	case_list ::= case_item { WS? "," WS? case_item } [ WS? "," ] ;
	87	case_item ::= [ "case" WS1 ] ident [ "(" WS? case_payload? WS? ")" ] [ WS? "=" WS? expr ] ;		87	case_item ::= [ "case" WS1 ] ident [ "(" WS? case_payload? WS? ")" ] [ WS? "=" WS? expr ] ;
	88	case_payload ::= case_field { WS? "," WS? case_field } [ WS? "," ] ;		88	case_payload ::= case_field { WS? "," WS? case_field } [ WS? "," ] ;
	89	case_field ::= ident WS? ":" WS? type_expr \| type_expr ;		89	case_field ::= ident WS? ":" WS? type_expr \| type_expr ;
	90			90
	91	flags_decl ::= { attr_prefix WS? } "flags" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? flag_list? WS? "}" ;		91	flags_decl ::= { attr_prefix WS? } "flags" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? flag_list? WS? "}" ;
	92	flag_list ::= flag_item { WS? "," WS? flag_item } [ WS? "," ] ;		92	flag_list ::= flag_item { WS? "," WS? flag_item } [ WS? "," ] ;
	93	flag_item ::= ident [ WS? "=" WS? expr ] ;		93	flag_item ::= ident [ WS? "=" WS? expr ] ;
	94			94
	95	trait_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "trait" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS		95	trait_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "trait" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS
	>	? trait_item* WS? "}" ;		>	? trait_item* WS? "}" ;
	96	trait_item ::= proc_signature \| const_decl \| associated_type_decl ;		96	trait_item ::= proc_signature \| const_decl \| associated_type_decl ;
	97			97
	98	associated_type_decl ::= "type" WS1 ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ] ;		98	associated_type_decl ::= "type" WS1 ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ] ;
	99			99
	100	impl_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "impl" WS1 impl_head [ WS? where_clause ] WS? "{" WS? impl_item* WS?		100	impl_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "impl" WS1 impl_head [ WS? where_clause ] WS? "{" WS? impl_item* WS?
	>	"}" ;		>	"}" ;
	101	impl_head ::= type_expr \| type_expr WS1 "for" WS1 type_expr ;		101	impl_head ::= type_expr \| type_expr WS1 "for" WS1 type_expr ;
	102	impl_item ::= const_decl \| type_alias_decl \| associated_type_decl \| proc_decl ;		102	impl_item ::= const_decl \| type_alias_decl \| associated_type_decl \| proc_decl ;
	103			103
	104	proc_signature ::= { attr_prefix WS? } "proc" WS1 ident [ generic_params ]		104	proc_signature ::= { attr_prefix WS? } "proc" WS1 ident [ generic_params ]
	105	"(" WS? param_list? WS? ")"		105	"(" WS? param_list? WS? ")"
	106	[ WS? "->" WS? type_expr ]		106	[ WS? "->" WS? type_expr ]
	107	WS? proc_suffix*		107	WS? proc_suffix*
	108	WS? ";"		108	WS? ";"
	109	;		109	;
	110			110
	111	proc_decl ::= { attr_prefix WS? } [ visibility WS1 ] proc_modifier* [ extern_clause WS1 ] "proc" WS1 proc_name [ generic		111	proc_decl ::= { attr_prefix WS? } [ visibility WS1 ] proc_modifier* [ extern_clause WS1 ] "proc" WS1 proc_name [ generic
	>	_params ]		>	_params ]
	112	"(" WS? param_list? WS? ")"		112	"(" WS? param_list? WS? ")"
	113	[ WS? "->" WS? type_expr ]		113	[ WS? "->" WS? type_expr ]
	114	WS? proc_suffix*		114	WS? proc_suffix*
	115	WS? ( block \| ";" )		115	WS? ( block \| ";" )
	116	;		116	;
	117			117
	118	proc_name ::= ident \| "operator" WS? operator_symbol ;		118	proc_name ::= ident \| "operator" WS? operator_symbol ;
	119	operator_symbol ::= "+" \| "-" \| "*" \| "/" \| "%"		119	operator_symbol ::= "+" \| "-" \| "*" \| "/" \| "%"
	120	\| "==" \| "!=" \| "<" \| "<=" \| ">" \| ">="		120	\| "==" \| "!=" \| "<" \| "<=" \| ">" \| ">="
	121	\| "[]" \| "()" ;		121	\| "[]" \| "()" ;
	122			122
	123	proc_modifier ::= "async" WS1		123	proc_modifier ::= "async" WS1
	124	\| "unsafe" WS1		124	\| "unsafe" WS1
	125	\| "const" WS1		125	\| "const" WS1
	126	\| "inline" WS1		126	\| "inline" WS1
	127	\| "noinline" WS1		127	\| "noinline" WS1
	128	\| "naked" WS1		128	\| "naked" WS1
	129	\| "interrupt" WS1		129	\| "interrupt" WS1
	130	;		130	;
	131			131
	132	proc_suffix ::= effects_clause		132	proc_suffix ::= effects_clause
	133	\| requires_clause		133	\| requires_clause
	134	\| where_clause		134	\| where_clause
	135	\| "noexcept"		135	\| "noexcept"
	136	;		136	;
	137			137
	138	extern_block ::= { attr_prefix WS? } "extern" WS1 extern_abi WS? "{" WS? extern_item* WS? "}" ;		138	extern_block ::= { attr_prefix WS? } "extern" WS1 extern_abi WS? "{" WS? extern_item* WS? "}" ;
	139	extern_item ::= extern_proc_decl \| extern_type_decl \| const_decl ;		139	extern_item ::= extern_proc_decl \| extern_type_decl \| const_decl ;
	140			140
	141	extern_proc_decl ::= { attr_prefix WS? } "proc" WS1 ident [ generic_params ]		141	extern_proc_decl ::= { attr_prefix WS? } "proc" WS1 ident [ generic_params ]
	142	"(" WS? param_list? WS? ")"		142	"(" WS? param_list? WS? ")"
	143	[ WS? "->" WS? type_expr ]		143	[ WS? "->" WS? type_expr ]
	144	WS? proc_suffix*		144	WS? proc_suffix*
	145	WS? ";"		145	WS? ";"
	146	;		146	;
	147			147
	148	extern_clause ::= "extern" WS1 extern_abi ;		148	extern_clause ::= "extern" WS1 extern_abi ;
	149	extern_abi ::= callconv \| string_lit ;		149	extern_abi ::= callconv \| string_lit ;
	150	callconv ::= "C" \| "sysv64" \| "win64" \| "interrupt" \| "naked" ;		150	callconv ::= "C" \| "sysv64" \| "win64" \| "interrupt" \| "naked" ;
	151			151
	152	intrinsic_decl ::= { attr_prefix WS? } "intrinsic" WS1 ident [ generic_params ]		152	intrinsic_decl ::= { attr_prefix WS? } "intrinsic" WS1 ident [ generic_params ]
	153	"(" WS? param_list? WS? ")"		153	"(" WS? param_list? WS? ")"
	154	[ WS? "->" WS? type_expr ]		154	[ WS? "->" WS? type_expr ]
	155	WS? ";"		155	WS? ";"
	156	;		156	;
	157			157
	158	<<< macro / compiler / pass / backend / diagnostic / entry are currently		158	<<< macro / compiler / pass / backend / diagnostic / entry are currently
	159	preserved as top-level meta items by the frontend. They accept either a		159	preserved as top-level meta items by the frontend. They accept either a
	160	trailing ";" form or a raw "{ ... }" body, but the body is not yet parsed		160	trailing ";" form or a raw "{ ... }" body, but the body is not yet parsed
	161	into a dedicated structured AST. Keep these rules narrow and parser-aligned. >>>		161	into a dedicated structured AST. Keep these rules narrow and parser-aligned. >>>
	162	macro_decl ::= { attr_prefix WS? } "macro" WS1 ident [ "(" WS? macro_param_list? WS? ")" ] WS? meta_tail ;		162	macro_decl ::= { attr_prefix WS? } "macro" WS1 ident [ "(" WS? macro_param_list? WS? ")" ] WS? meta_tail ;
	163	macro_param_list ::= macro_param { WS? "," WS? macro_param } [ WS? "," ] ;		163	macro_param_list ::= macro_param { WS? "," WS? macro_param } [ WS? "," ] ;
	164	macro_param ::= ident [ WS? ":" WS? macro_kind ] ;		164	macro_param ::= ident [ WS? ":" WS? macro_kind ] ;
	165	macro_kind ::= "expr" \| "stmt" \| "type" \| "ident" \| "block" \| "item" ;		165	macro_kind ::= "expr" \| "stmt" \| "type" \| "ident" \| "block" \| "item" ;
	166			166
	167	static_assert_decl ::= "static_assert" WS? "(" WS? expr [ WS? "," WS? expr ] WS? ")" ;		167	static_assert_decl ::= "static_assert" WS? "(" WS? expr [ WS? "," WS? expr ] WS? ")" ;
	168	test_decl ::= { attr_prefix WS? } "test" WS1 string_lit WS? block ;		168	test_decl ::= { attr_prefix WS? } "test" WS1 string_lit WS? block ;
	169	bench_decl ::= { attr_prefix WS? } "bench" WS1 string_lit WS? block ;		169	bench_decl ::= { attr_prefix WS? } "bench" WS1 string_lit WS? block ;
	170	entry_decl ::= { attr_prefix WS? } "entry" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;		170	entry_decl ::= { attr_prefix WS? } "entry" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;
	171			171
	172	visibility ::= "pub" \| "priv" \| "pub" WS? "(" WS? visibility_scope WS? ")" ;		172	visibility ::= "pub" \| "priv" \| "pub" WS? "(" WS? visibility_scope WS? ")" ;
	173	visibility_scope ::= "package" \| "module" \| "super" ;		173	visibility_scope ::= "package" \| "module" \| "super" ;
	174			174
	175	generic_params ::= "[" WS? generic_param_list? WS? "]" ;		175	generic_params ::= "[" WS? generic_param_list? WS? "]" ;
	176	generic_param_list ::= generic_param { WS? "," WS? generic_param } [ WS? "," ] ;		176	generic_param_list ::= generic_param { WS? "," WS? generic_param } [ WS? "," ] ;
	177	generic_param ::= ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ]		177	generic_param ::= ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ]
	178	\| "const" WS1 ident WS? ":" WS? type_expr		178	\| "const" WS1 ident WS? ":" WS? type_expr
	179	\| "comptime" WS1 ident WS? ":" WS? type_expr		179	\| "comptime" WS1 ident WS? ":" WS? type_expr
	180	;		180	;
	181			181
	182	where_clause ::= "where" WS1 where_bounds ;		182	where_clause ::= "where" WS1 where_bounds ;
	183	where_bounds ::= where_bound { WS? "," WS? where_bound } [ WS? "," ] ;		183	where_bounds ::= where_bound { WS? "," WS? where_bound } [ WS? "," ] ;
	184	where_bound ::= type_expr WS? ":" WS? trait_bound		184	where_bound ::= type_expr WS? ":" WS? trait_bound
	185	\| type_expr WS? "==" WS? type_expr		185	\| type_expr WS? "==" WS? type_expr
	186	\| expr WS? rel_op WS? expr		186	\| expr WS? rel_op WS? expr
	187	;		187	;
	188			188
	189	trait_bound ::= type_expr { WS? "+" WS? type_expr } ;		189	trait_bound ::= type_expr { WS? "+" WS? type_expr } ;
	190			190
	191	param_list ::= param { WS? "," WS? param } [ WS? "," ] ;		191	param_list ::= param { WS? "," WS? param } [ WS? "," ] ;
	192	param ::= self_param \| normal_param \| variadic_param ;		192	param ::= self_param \| normal_param \| variadic_param ;
	193	self_param ::= [ "&" WS? ] [ "mut" WS1 ] "self" ;		193	self_param ::= [ "&" WS? ] [ "mut" WS1 ] "self" ;
	194	normal_param ::= [ param_mode WS1 ] pattern [ WS? ":" WS? type_expr ] [ WS? "=" WS? expr ] ;		194	normal_param ::= [ param_mode WS1 ] pattern [ WS? ":" WS? type_expr ] [ WS? "=" WS? expr ] ;
	195	variadic_param ::= "..." \| ident WS? ":" WS? "..." type_expr ;		195	variadic_param ::= "..." \| ident WS? ":" WS? "..." type_expr ;
	196	param_mode ::= "mut" \| "owned" \| "borrow" \| "move" ;		196	param_mode ::= "mut" \| "owned" \| "borrow" \| "move" ;
	197			197
	198	effects_clause ::= "effects" WS? "(" WS? ident_list? WS? ")" ;		198	effects_clause ::= "effects" WS? "(" WS? ident_list? WS? ")" ;
	199	requires_clause ::= "requires" WS? "(" WS? capability_list? WS? ")" ;		199	requires_clause ::= "requires" WS? "(" WS? capability_list? WS? ")" ;
	200	capability_list ::= capability { WS? "," WS? capability } [ WS? "," ] ;		200	capability_list ::= capability { WS? "," WS? capability } [ WS? "," ] ;
	201	capability ::= ident { "." ident } ;		201	capability ::= ident { "." ident } ;
	202			202
	203	module_path ::= relative? package_parts ;		203	module_path ::= relative? package_parts ;
	204	package_path ::= relative? package_parts ;		204	package_path ::= relative? package_parts ;
	205	relative ::= { "." } ;		205	relative ::= { "." } ;
	206	package_parts ::= ident { ( "/" \| "." \| "::" ) ident } ;		206	package_parts ::= ident { ( "/" \| "." \| "::" ) ident } ;
	207	ident_list ::= ident { WS? "," WS? ident } [ WS? "," ] ;		207	ident_list ::= ident { WS? "," WS? ident } [ WS? "," ] ;
	208			208
	209	query_decl ::= { attr_prefix WS? } "query" WS1 ident		209	query_decl ::= { attr_prefix WS? } "query" WS1 ident
	210	"(" WS? param_list? WS? ")"		210	"(" WS? param_list? WS? ")"
	211	WS? "->" WS? type_expr		211	WS? "->" WS? type_expr
	212	WS? query_body ;		212	WS? query_body ;
	213			213
	214	query_body ::= block \| ";" ;		214	query_body ::= block \| ";" ;
	215			215
	216	<<< ================= Meta Declarations ================= >>>		216	<<< ================= Meta Declarations ================= >>>
	217			217
	218	compiler_decl ::= { attr_prefix WS? } "compiler" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;		218	compiler_decl ::= { attr_prefix WS? } "compiler" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;
	219	pass_decl ::= { attr_prefix WS? } "pass" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;		219	pass_decl ::= { attr_prefix WS? } "pass" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;
	220	backend_decl ::= { attr_prefix WS? } "backend" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;		220	backend_decl ::= { attr_prefix WS? } "backend" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;
	221	diagnostic_decl ::= { attr_prefix WS? } "diagnostic" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;		221	diagnostic_decl ::= { attr_prefix WS? } "diagnostic" WS1 ident_or_string [ WS? meta_args ] WS? meta_tail ;
	222			222
	223	ident_or_string ::= ident \| string_lit ;		223	ident_or_string ::= ident \| string_lit ;
	224	meta_args ::= "(" WS? meta_arg_list? WS? ")" ;		224	meta_args ::= "(" WS? meta_arg_list? WS? ")" ;
	225	meta_arg_list ::= meta_arg { WS? "," WS? meta_arg } [ WS? "," ] ;		225	meta_arg_list ::= meta_arg { WS? "," WS? meta_arg } [ WS? "," ] ;
	226	meta_arg ::= ident_or_string ;		226	meta_arg ::= ident_or_string ;
	227	meta_tail ::= block \| ";" ;		227	meta_tail ::= block \| ";" ;
	228			228
	229	<<< ================= Attributes ================= >>>		229	<<< ================= Attributes ================= >>>
	230			230
	231	attr_prefix ::= outer_attribute \| doc_comment \| docstring ;		231	attr_prefix ::= outer_attribute \| doc_comment \| docstring ;
	232	inner_attribute ::= "#![" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;		232	inner_attribute ::= "#![" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;
	233	outer_attribute ::= "#[" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;		233	outer_attribute ::= "#[" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;
	234	doc_comment ::= "///" { ~NEWLINE ANY } ;		234	doc_comment ::= "///" { ~NEWLINE ANY } ;
	235	docstring ::= raw_string_lit ;		235	docstring ::= raw_string_lit ;
	236			236
	237	attr_path ::= ident { "." ident } ;		237	attr_path ::= ident { "." ident } ;
	238	attr_arg_list ::= attr_arg { WS? "," WS? attr_arg } [ WS? "," ] ;		238	attr_arg_list ::= attr_arg { WS? "," WS? attr_arg } [ WS? "," ] ;
	239	attr_arg ::= ident		239	attr_arg ::= ident
	240	\| string_lit		240	\| string_lit
	241	\| int_lit		241	\| int_lit
	242	\| bool_lit		242	\| bool_lit
	243	\| ident WS? "=" WS? literal		243	\| ident WS? "=" WS? literal
	244	;		244	;
	245			245
	246	<<< ================= Blocks / Statements ================= >>>		246	<<< ================= Blocks / Statements ================= >>>
	247			247
	248	block ::= "{" WS? { stmt WS? } "}" ;		248	block ::= "{" WS? { stmt WS? } "}" ;
	249			249
	250	stmt ::= local_const_stmt stmt_end		250	stmt ::= local_const_stmt stmt_end
	251	\| let_stmt stmt_end		251	\| let_stmt stmt_end
	252	\| set_stmt stmt_end		252	\| set_stmt stmt_end
	253	\| give_stmt stmt_end		253	\| give_stmt stmt_end
	254	\| try_stmt stmt_end		254	\| try_stmt stmt_end
	255	\| defer_stmt		255	\| defer_stmt
	256	\| asm_stmt stmt_end		256	\| asm_stmt stmt_end
	257	\| unsafe_stmt		257	\| unsafe_stmt
	258	\| emit_stmt stmt_end		258	\| emit_stmt stmt_end
	259	\| assert_stmt stmt_end		259	\| assert_stmt stmt_end
	260	\| panic_stmt stmt_end		260	\| panic_stmt stmt_end
	261	\| unreachable_stmt stmt_end		261	\| unreachable_stmt stmt_end
	262	\| if_stmt		262	\| if_stmt
	263	\| while_stmt		263	\| while_stmt
	264	\| loop_stmt		264	\| loop_stmt
	265	\| for_stmt		265	\| for_stmt
	266	\| break_stmt stmt_end		266	\| break_stmt stmt_end
	267	\| continue_stmt stmt_end		267	\| continue_stmt stmt_end
	268	\| select_stmt		268	\| select_stmt
	269	\| match_stmt		269	\| match_stmt
	270	\| when_match_stmt		270	\| when_match_stmt
	271	\| with_stmt		271	\| with_stmt
	272	\| critical_stmt		272	\| critical_stmt
	273	\| expr_stmt stmt_end		273	\| expr_stmt stmt_end
	274	;		274	;
	275			275
	276	stmt_end ::= WS? ";" ;		276	stmt_end ::= WS? ";" ;
	277			277
	278	local_const_stmt ::= "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		278	local_const_stmt ::= "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	279	let_stmt ::= "let" WS1 [ "mut" WS1 ] pattern [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		279	let_stmt ::= "let" WS1 [ "mut" WS1 ] pattern [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	280	<<< assign_target stays intentionally syntactic here; projection validity and aliasing		280	<<< assign_target stays intentionally syntactic here; projection validity and aliasing
	281	are enforced later by sema/typeck/borrowck on structured HIR/MIR places. >>>		281	are enforced later by sema/typeck/borrowck on structured HIR/MIR places. >>>
	282	set_stmt ::= "set" WS1 assign_target WS? assign_op WS? expr ;		282	set_stmt ::= "set" WS1 assign_target WS? assign_op WS? expr ;
	283	assign_target ::= unary_expr ;		283	assign_target ::= unary_expr ;
	284			284
	285	give_stmt ::= "give" [ WS1 expr ] ;		285	give_stmt ::= "give" [ WS1 expr ] ;
	286	try_stmt ::= "try" WS1 expr ;		286	try_stmt ::= "try" WS1 expr ;
	287	defer_stmt ::= "defer" WS? block ;		287	defer_stmt ::= "defer" WS? block ;
	288			288
	289	asm_stmt ::= "asm" WS? "(" WS? asm_arg_list? WS? ")" ;		289	asm_stmt ::= "asm" WS? "(" WS? asm_arg_list? WS? ")" ;
	290	asm_arg_list ::= asm_arg { WS? "," WS? asm_arg } [ WS? "," ] ;		290	asm_arg_list ::= asm_arg { WS? "," WS? asm_arg } [ WS? "," ] ;
	291	asm_arg ::= string_lit \| ident WS? "(" WS? arg_list? WS? ")" \| ident WS? ":" WS? expr ;		291	asm_arg ::= string_lit \| ident WS? "(" WS? arg_list? WS? ")" \| ident WS? ":" WS? expr ;
	292			292
	293	unsafe_stmt ::= "unsafe" WS? block ;		293	unsafe_stmt ::= "unsafe" WS? block ;
	294			294
	295	emit_stmt ::= "emit" WS1 expr ;		295	emit_stmt ::= "emit" WS1 expr ;
	296	assert_stmt ::= "assert" WS1 expr [ WS? "," WS? expr ] ;		296	assert_stmt ::= "assert" WS1 expr [ WS? "," WS? expr ] ;
	297	panic_stmt ::= "panic" WS1 expr ;		297	panic_stmt ::= "panic" WS1 expr ;
	298	unreachable_stmt ::= "unreachable" ;		298	unreachable_stmt ::= "unreachable" ;
	299			299
	300	if_stmt ::= "if" WS1 expr WS? block		300	if_stmt ::= "if" WS1 expr WS? block
	301	{ WS? "elif" WS1 expr WS? block }		301	{ WS? "elif" WS1 expr WS? block }
	302	[ WS? "else" WS? block ] ;		302	[ WS? "else" WS? block ] ;
	303			303
	304	while_stmt ::= "while" WS1 expr WS? block ;		304	while_stmt ::= "while" WS1 expr WS? block ;
	305	loop_stmt ::= "loop" WS? block ;		305	loop_stmt ::= "loop" WS? block ;
	306	for_stmt ::= "for" WS1 pattern WS1 "in" WS1 expr WS? block ;		306	for_stmt ::= "for" WS1 pattern WS1 "in" WS1 expr WS? block ;
	307			307
	308	break_stmt ::= "break" [ WS1 expr ] ;		308	break_stmt ::= "break" [ WS1 expr ] ;
	309	continue_stmt ::= "continue" ;		309	continue_stmt ::= "continue" ;
	310			310
	311	select_stmt ::= "select" WS1 expr WS? "{" WS?		311	select_stmt ::= "select" WS1 expr WS? "{" WS?
	312	{ "when" WS1 pattern WS? block WS? }		312	{ "when" WS1 pattern WS? block WS? }
	313	[ "else" WS? block ]		313	[ "else" WS? block ]
	314	WS? "}" ;		314	WS? "}" ;
	315			315
	316	match_stmt ::= "match" WS1 expr WS?		316	match_stmt ::= "match" WS1 expr WS?
	317	"{" WS?		317	"{" WS?
	318	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }		318	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }
	319	[ WS? "else" WS? match_arm_body ]		319	[ WS? "else" WS? match_arm_body ]
	320	WS? "}" ;		320	WS? "}" ;
	321			321
	322	match_arm_body ::= block \| "=>" WS? expr WS? ";" ;		322	match_arm_body ::= block \| "=>" WS? expr WS? ";" ;
	323			323
	324	when_match_stmt ::= "when" WS1 expr WS1 "is" WS1 pattern WS? block ;		324	when_match_stmt ::= "when" WS1 expr WS1 "is" WS1 pattern WS? block ;
	325	with_stmt ::= "with" WS1 expr [ WS1 "as" WS1 pattern ] WS? block ;		325	with_stmt ::= "with" WS1 expr [ WS1 "as" WS1 pattern ] WS? block ;
	326	critical_stmt ::= "critical" WS? block ;		326	critical_stmt ::= "critical" WS? block ;
	327	expr_stmt ::= expr ;		327	expr_stmt ::= expr ;
	328			328
	329	<<< ================= Expressions ================= >>>		329	<<< ================= Expressions ================= >>>
	330			330
	331	expr ::= assign_expr ;		331	expr ::= assign_expr ;
	332			332
	333	assign_expr ::= ternary_expr [ WS? assign_op WS? assign_expr ] ;		333	assign_expr ::= ternary_expr [ WS? assign_op WS? assign_expr ] ;
	334	assign_op ::= "=" \| "+=" \| "-=" \| "*=" \| "/=" \| "%=" \| "&=" \| "\|=" \| "^=" \| "<<=" \| ">>=" ;		334	assign_op ::= "=" \| "+=" \| "-=" \| "*=" \| "/=" \| "%=" \| "&=" \| "\|=" \| "^=" \| "<<=" \| ">>=" ;
	335			335
	336	ternary_expr ::= coalesce_expr [ WS? "?" WS? expr WS? ":" WS? expr ] ;		336	ternary_expr ::= coalesce_expr [ WS? "?" WS? expr WS? ":" WS? expr ] ;
	337	coalesce_expr ::= range_expr { WS? "??" WS? range_expr } ;		337	coalesce_expr ::= range_expr { WS? "??" WS? range_expr } ;
	338	range_expr ::= or_expr [ WS? ( ".." \| "..=" ) WS? or_expr ] ;		338	range_expr ::= or_expr [ WS? ( ".." \| "..=" ) WS? or_expr ] ;
	339			339
	340	or_expr ::= and_expr { WS? ( "or" \| "\|\|" ) WS? and_expr } ;		340	or_expr ::= and_expr { WS? ( "or" \| "\|\|" ) WS? and_expr } ;
	341	and_expr ::= bit_or_expr { WS? ( "and" \| "&&" ) WS? bit_or_expr } ;		341	and_expr ::= bit_or_expr { WS? ( "and" \| "&&" ) WS? bit_or_expr } ;
	342			342
	343	bit_or_expr ::= bit_xor_expr { WS? "\|" WS? bit_xor_expr } ;		343	bit_or_expr ::= bit_xor_expr { WS? "\|" WS? bit_xor_expr } ;
	344	bit_xor_expr ::= bit_and_expr { WS? "^" WS? bit_and_expr } ;		344	bit_xor_expr ::= bit_and_expr { WS? "^" WS? bit_and_expr } ;
	345	bit_and_expr ::= eq_expr { WS? "&" WS? eq_expr } ;		345	bit_and_expr ::= eq_expr { WS? "&" WS? eq_expr } ;
	346			346
	347	eq_expr ::= rel_expr { WS? ( "==" \| "!=" ) WS? rel_expr } ;		347	eq_expr ::= rel_expr { WS? ( "==" \| "!=" ) WS? rel_expr } ;
	348	rel_expr ::= shift_expr { WS? rel_op WS? shift_expr } ;		348	rel_expr ::= shift_expr { WS? rel_op WS? shift_expr } ;
	349	rel_op ::= "<" \| "<=" \| ">" \| ">=" \| "in" \| "not" WS1 "in" ;		349	rel_op ::= "<" \| "<=" \| ">" \| ">=" \| "in" \| "not" WS1 "in" ;
	350			350
	351	shift_expr ::= add_expr { WS? ( "<<" \| ">>" ) WS? add_expr } ;		351	shift_expr ::= add_expr { WS? ( "<<" \| ">>" ) WS? add_expr } ;
	352	add_expr ::= mul_expr { WS? ( "+" \| "-" ) WS? mul_expr } ;		352	add_expr ::= mul_expr { WS? ( "+" \| "-" ) WS? mul_expr } ;
	353	mul_expr ::= cast_expr { WS? ( "*" \| "/" \| "%" ) WS? cast_expr } ;		353	mul_expr ::= cast_expr { WS? ( "*" \| "/" \| "%" ) WS? cast_expr } ;
	354			354
	355	cast_expr ::= unary_expr { WS? ( "as" WS? type_expr \| "is" WS? pattern \| "is" WS1 "not" WS1 pattern ) } ;		355	cast_expr ::= unary_expr { WS? ( "as" WS? type_expr \| "is" WS? pattern \| "is" WS1 "not" WS1 pattern ) } ;
	356			356
	357	<<< unary borrow and move syntax are accepted at parse time; whether a use is		357	<<< unary borrow and move syntax are accepted at parse time; whether a use is
	358	actually a copy or a move is decided later from inferred types. >>>		358	actually a copy or a move is decided later from inferred types. >>>
	359	unary_expr ::= ( "not" \| "-" \| "~" \| "*" \| "&" \| "move" \| "await" ) WS? unary_expr		359	unary_expr ::= ( "not" \| "-" \| "~" \| "*" \| "&" \| "move" \| "await" ) WS? unary_expr
	360	\| postfix_expr		360	\| postfix_expr
	361	;		361	;
	362			362
	363	<<< postfix chains define the full place surface used later by ownership and		363	<<< postfix chains define the full place surface used later by ownership and
	364	borrow analysis: field projection, indexing, call, try and await suffixes. >>>		364	borrow analysis: field projection, indexing, call, try and await suffixes. >>>
	365	postfix_expr ::= primary { call_suffix \| member_suffix \| index_suffix \| try_suffix \| await_suffix } ;		365	postfix_expr ::= primary { call_suffix \| member_suffix \| index_suffix \| try_suffix \| await_suffix } ;
	366	call_suffix ::= "(" WS? arg_list? WS? ")" ;		366	call_suffix ::= "(" WS? arg_list? WS? ")" ;
	367	member_suffix ::= "." ident ;		367	member_suffix ::= "." ident ;
	368	index_suffix ::= "[" WS? index_expr WS? "]" ;		368	index_suffix ::= "[" WS? index_expr WS? "]" ;
	369	try_suffix ::= "?" ;		369	try_suffix ::= "?" ;
	370	await_suffix ::= "." "await" ;		370	await_suffix ::= "." "await" ;
	371			371
	372	index_expr ::= expr \| slice_expr ;		372	index_expr ::= expr \| slice_expr ;
	373	slice_expr ::= [ expr ] ":" [ expr ] [ ":" expr ] ;		373	slice_expr ::= [ expr ] ":" [ expr ] [ ":" expr ] ;
	374			374
	375	primary ::= literal		375	primary ::= literal
	376	\| builtin_expr		376	\| builtin_expr
	377	\| path_expr		377	\| path_expr
	378	\| struct_lit		378	\| struct_lit
	379	\| list_lit		379	\| list_lit
	380	\| tuple_lit		380	\| tuple_lit
	381	\| set_lit		381	\| set_lit
	382	\| map_lit		382	\| map_lit
	383	\| bytes_lit		383	\| bytes_lit
	384	\| resource_lit		384	\| resource_lit
	385	\| if_expr		385	\| if_expr
	386	\| proc_expr		386	\| proc_expr
	387	\| match_expr		387	\| match_expr
	388	\| lambda_expr		388	\| lambda_expr
	389	\| unsafe_expr		389	\| unsafe_expr
	390	\| block		390	\| block
	391	\| "(" WS? expr WS? ")"		391	\| "(" WS? expr WS? ")"
	392	;		392	;
	393			393
	394	path_expr ::= ident { ( "." \| "::" ) ident } ;		394	path_expr ::= ident { ( "." \| "::" ) ident } ;
	395			395
	396	arg_list ::= arg { WS? "," WS? arg } [ WS? "," ] ;		396	arg_list ::= arg { WS? "," WS? arg } [ WS? "," ] ;
	397	arg ::= ident WS? ":" WS? expr \| expr ;		397	arg ::= ident WS? ":" WS? expr \| expr ;
	398			398
	399	tuple_lit ::= "(" WS? expr WS? "," WS? expr { WS? "," WS? expr } [ WS? "," ] WS? ")" ;		399	tuple_lit ::= "(" WS? expr WS? "," WS? expr { WS? "," WS? expr } [ WS? "," ] WS? ")" ;
	400	set_lit ::= "set" WS? "{" WS? arg_list? WS? "}" ;		400	set_lit ::= "set" WS? "{" WS? arg_list? WS? "}" ;
	401			401
	402	map_lit ::= "map" WS? "{" WS? map_items? WS? "}" ;		402	map_lit ::= "map" WS? "{" WS? map_items? WS? "}" ;
	403	map_items ::= map_item { WS? "," WS? map_item } [ WS? "," ] ;		403	map_items ::= map_item { WS? "," WS? map_item } [ WS? "," ] ;
	404	map_item ::= expr WS? ":" WS? expr ;		404	map_item ::= expr WS? ":" WS? expr ;
	405			405
	406	bytes_lit ::= "b" string_lit ;		406	bytes_lit ::= "b" string_lit ;
	407			407
	408	resource_lit ::= "resource" WS? "{" WS? resource_items? WS? "}" ;		408	resource_lit ::= "resource" WS? "{" WS? resource_items? WS? "}" ;
	409	resource_items ::= resource_item { WS? "," WS? resource_item } [ WS? "," ] ;		409	resource_items ::= resource_item { WS? "," WS? resource_item } [ WS? "," ] ;
	410	resource_item ::= ident WS? ":" WS? expr ;		410	resource_item ::= ident WS? ":" WS? expr ;
	411			411
	412	struct_lit ::= type_path WS? "{" WS? field_init_list? WS? "}" ;		412	struct_lit ::= type_path WS? "{" WS? field_init_list? WS? "}" ;
	413	type_path ::= ident { ( "." \| "::" ) ident } ;		413	type_path ::= ident { ( "." \| "::" ) ident } ;
	414	field_init_list ::= field_init { WS? "," WS? field_init } [ WS? "," ] ;		414	field_init_list ::= field_init { WS? "," WS? field_init } [ WS? "," ] ;
	415	field_init ::= ident WS? ":" WS? expr		415	field_init ::= ident WS? ":" WS? expr
	416	\| ident		416	\| ident
	417	\| ".." expr		417	\| ".." expr
	418	;		418	;
	419			419
	420	if_expr ::= "if" WS1 expr WS? block		420	if_expr ::= "if" WS1 expr WS? block
	421	{ WS? "elif" WS1 expr WS? block }		421	{ WS? "elif" WS1 expr WS? block }
	422	[ WS? "else" WS? block ] ;		422	[ WS? "else" WS? block ] ;
	423			423
	424	proc_expr ::= { attr_prefix WS? } proc_modifier* "proc" WS? "(" WS? param_list? WS? ")"		424	proc_expr ::= { attr_prefix WS? } proc_modifier* "proc" WS? "(" WS? param_list? WS? ")"
	425	[ WS? "->" WS? type_expr ]		425	[ WS? "->" WS? type_expr ]
	426	WS? proc_suffix*		426	WS? proc_suffix*
	427	WS? block ;		427	WS? block ;
	428			428
	429	match_expr ::= "match" WS1 expr WS?		429	match_expr ::= "match" WS1 expr WS?
	430	"{" WS?		430	"{" WS?
	431	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }		431	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }
	432	[ WS? "else" WS? match_arm_body ]		432	[ WS? "else" WS? match_arm_body ]
	433	WS? "}" ;		433	WS? "}" ;
	434			434
	435	lambda_expr ::= "\|" WS? param_list? WS? "\|" WS? ( expr \| block ) ;		435	lambda_expr ::= "\|" WS? param_list? WS? "\|" WS? ( expr \| block ) ;
	436	unsafe_expr ::= "unsafe" WS? block ;		436	unsafe_expr ::= "unsafe" WS? block ;
	437			437
	438	builtin_expr ::= sizeof_expr \| alignof_expr \| offsetof_expr \| typeof_expr \| nameof_expr ;		438	builtin_expr ::= sizeof_expr \| alignof_expr \| offsetof_expr \| typeof_expr \| nameof_expr ;
	439	sizeof_expr ::= "sizeof" WS? "(" WS? ( type_expr \| expr ) WS? ")" ;		439	sizeof_expr ::= "sizeof" WS? "(" WS? ( type_expr \| expr ) WS? ")" ;
	440	alignof_expr ::= "alignof" WS? "(" WS? type_expr WS? ")" ;		440	alignof_expr ::= "alignof" WS? "(" WS? type_expr WS? ")" ;
	441	offsetof_expr ::= "offsetof" WS? "(" WS? type_expr WS? "," WS? ident WS? ")" ;		441	offsetof_expr ::= "offsetof" WS? "(" WS? type_expr WS? "," WS? ident WS? ")" ;
	442	typeof_expr ::= "typeof" WS? "(" WS? expr WS? ")" ;		442	typeof_expr ::= "typeof" WS? "(" WS? expr WS? ")" ;
	443	nameof_expr ::= "nameof" WS? "(" WS? path_expr WS? ")" ;		443	nameof_expr ::= "nameof" WS? "(" WS? path_expr WS? ")" ;
	444			444
	445	<<< ================= Patterns ================= >>>		445	<<< ================= Patterns ================= >>>
	446			446
	447	pattern ::= pattern_or ;		447	pattern ::= pattern_or ;
	448	pattern_or ::= pattern_atom { WS? "\|" WS? pattern_atom } ;		448	pattern_or ::= pattern_atom { WS? "\|" WS? pattern_atom } ;
	449			449
	450	pattern_atom ::= "_"		450	pattern_atom ::= "_"
	451	\| literal		451	\| literal
	452	\| "mut" WS1 pattern_bind		452	\| "mut" WS1 pattern_bind
	453	\| "ref" WS1 pattern_bind		453	\| "ref" WS1 pattern_bind
	454	\| pattern_bind		454	\| pattern_bind
	455	\| pattern_ctor		455	\| pattern_ctor
	456	\| pattern_struct		456	\| pattern_struct
	457	\| pattern_tuple		457	\| pattern_tuple
	458	\| pattern_list		458	\| pattern_list
	459	\| pattern_range		459	\| pattern_range
	460	;		460	;
	461			461
	462	pattern_bind ::= ident ;		462	pattern_bind ::= ident ;
	463	pattern_ctor ::= pattern_head [ "(" WS? pattern_args? WS? ")" ] ;		463	pattern_ctor ::= pattern_head [ "(" WS? pattern_args? WS? ")" ] ;
	464	pattern_head ::= ident { ( "." \| "::" ) ident } ;		464	pattern_head ::= ident { ( "." \| "::" ) ident } ;
	465	pattern_args ::= pattern { WS? "," WS? pattern } [ WS? "," ] ;		465	pattern_args ::= pattern { WS? "," WS? pattern } [ WS? "," ] ;
	466			466
	467	pattern_struct ::= pattern_head WS? "{" WS? pattern_fields? WS? "}" ;		467	pattern_struct ::= pattern_head WS? "{" WS? pattern_fields? WS? "}" ;
	468	pattern_fields ::= pattern_field { WS? "," WS? pattern_field } [ WS? "," ] ;		468	pattern_fields ::= pattern_field { WS? "," WS? pattern_field } [ WS? "," ] ;
	469	pattern_field ::= ident [ WS? ":" WS? pattern ] \| ".." ;		469	pattern_field ::= ident [ WS? ":" WS? pattern ] \| ".." ;
	470			470
	471	pattern_tuple ::= "(" WS? pattern WS? "," WS? pattern { WS? "," WS? pattern } [ WS? "," ] WS? ")" ;		471	pattern_tuple ::= "(" WS? pattern WS? "," WS? pattern { WS? "," WS? pattern } [ WS? "," ] WS? ")" ;
	472	pattern_list ::= "[" WS? pattern_args? WS? "]" ;		472	pattern_list ::= "[" WS? pattern_args? WS? "]" ;
	473	pattern_range ::= literal WS? ( ".." \| "..=" ) WS? literal ;		473	pattern_range ::= literal WS? ( ".." \| "..=" ) WS? literal ;
	474			474
	475	<<< ================= Types ================= >>>		475	<<< ================= Types ================= >>>
	476			476
	477	type_expr ::= type_union ;		477	type_expr ::= type_union ;
	478			478
	479	type_union ::= type_prefix { WS? "\|" WS? type_prefix } ;		479	type_union ::= type_prefix { WS? "\|" WS? type_prefix } ;
	480			480
	481	type_prefix ::= type_qualifier* type_atom ;		481	type_prefix ::= type_qualifier* type_atom ;
	482	type_qualifier ::= type_qual WS1 \| addr_space WS1 ;		482	type_qualifier ::= type_qual WS1 \| addr_space WS1 ;
	483			483
	484	type_qual ::= "const" \| "volatile" \| "atomic" \| "mut" \| "owned" \| "borrow" ;		484	type_qual ::= "const" \| "volatile" \| "atomic" \| "mut" \| "owned" \| "borrow" ;
	485	addr_space ::= "user" \| "kernel" \| "phys" \| "mmio" \| "dma" ;		485	addr_space ::= "user" \| "kernel" \| "phys" \| "mmio" \| "dma" ;
	486			486
	487	type_atom ::= reference_type		487	type_atom ::= reference_type
	488	\| pointer_type		488	\| pointer_type
	489	\| optional_type		489	\| optional_type
	490	\| fixed_array_type		490	\| fixed_array_type
	491	\| slice_type		491	\| slice_type
	492	\| tuple_type		492	\| tuple_type
	493	\| proc_type		493	\| proc_type
	494	\| dyn_type		494	\| dyn_type
	495	\| impl_trait_type		495	\| impl_trait_type
	496	\| type_primary		496	\| type_primary
	497	;		497	;
	498			498
	499	<<< shared and mutable references are part of the core surface grammar; lifetime,		499	<<< shared and mutable references are part of the core surface grammar; lifetime,
	500	aliasing and region closure remain semantic checks outside the parser. >>>		500	aliasing and region closure remain semantic checks outside the parser. >>>
	501	reference_type ::= "&" WS? [ lifetime WS? ] [ "mut" WS1 ] type_expr ;		501	reference_type ::= "&" WS? [ lifetime WS? ] [ "mut" WS1 ] type_expr ;
	502	pointer_type ::= "*" WS? [ "const" WS1 \| "mut" WS1 \| "volatile" WS1 \| addr_space WS1 ] type_expr ;		502	pointer_type ::= "*" WS? [ "const" WS1 \| "mut" WS1 \| "volatile" WS1 \| addr_space WS1 ] type_expr ;
	503	optional_type ::= "?" WS? type_expr ;		503	optional_type ::= "?" WS? type_expr ;
	504			504
	505	fixed_array_type ::= "[" WS? type_expr WS? ";" WS? expr WS? "]" ;		505	fixed_array_type ::= "[" WS? type_expr WS? ";" WS? expr WS? "]" ;
	506	slice_type ::= "[" WS? type_expr WS? "]" ;		506	slice_type ::= "[" WS? type_expr WS? "]" ;
	507			507
	508	tuple_type ::= "(" WS? type_expr WS? "," WS? type_expr { WS? "," WS? type_expr } [ WS? "," ] WS? ")" ;		508	tuple_type ::= "(" WS? type_expr WS? "," WS? type_expr { WS? "," WS? type_expr } [ WS? "," ] WS? ")" ;
	509	proc_type ::= "proc" WS? "(" WS? type_list? WS? ")" [ WS? "->" WS? type_expr ] ;		509	proc_type ::= "proc" WS? "(" WS? type_list? WS? ")" [ WS? "->" WS? type_expr ] ;
	510			510
	511	type_list ::= type_param { WS? "," WS? type_param } [ WS? "," ] ;		511	type_list ::= type_param { WS? "," WS? type_param } [ WS? "," ] ;
	512	type_param ::= ident WS? ":" WS? type_expr \| type_expr ;		512	type_param ::= ident WS? ":" WS? type_expr \| type_expr ;
	513			513
	514	dyn_type ::= "dyn" WS1 trait_bound ;		514	dyn_type ::= "dyn" WS1 trait_bound ;
	515	impl_trait_type ::= "impl" WS1 trait_bound ;		515	impl_trait_type ::= "impl" WS1 trait_bound ;
	516			516
	517	type_primary ::= type_path [ "[" WS? type_list? WS? "]" ]		517	type_primary ::= type_path [ "[" WS? type_list? WS? "]" ]
	518	\| primitive_type		518	\| primitive_type
	519	\| "Self"		519	\| "Self"
	520	;		520	;
	521			521
	522	lifetime ::= "'" ident ;		522	lifetime ::= "'" ident ;
	523			523
	524	primitive_type ::= "void"		524	primitive_type ::= "void"
	525	\| "never"		525	\| "never"
	526	\| "unit"		526	\| "unit"
	527	\| "bool"		527	\| "bool"
	528	\| "char"		528	\| "char"
	529	\| "rune"		529	\| "rune"
	530	\| "str"		530	\| "str"
	531	\| "string"		531	\| "string"
	532	\| "bytes"		532	\| "bytes"
	533	\| "cstr"		533	\| "cstr"
	534	\| "int"		534	\| "int"
	535	\| "i8" \| "i16" \| "i32" \| "i64" \| "i128"		535	\| "i8" \| "i16" \| "i32" \| "i64" \| "i128"
	536	\| "u8" \| "u16" \| "u32" \| "u64" \| "u128"		536	\| "u8" \| "u16" \| "u32" \| "u64" \| "u128"
	537	\| "usize" \| "isize"		537	\| "usize" \| "isize"
	538	\| "intptr" \| "uintptr"		538	\| "intptr" \| "uintptr"
	539	\| "f16" \| "f32" \| "f64" \| "f128"		539	\| "f16" \| "f32" \| "f64" \| "f128"
	540	\| "c_char" \| "c_int" \| "c_uint" \| "c_long" \| "c_ulong" \| "c_void"		540	\| "c_char" \| "c_int" \| "c_uint" \| "c_long" \| "c_ulong" \| "c_void"
	541	\| "TokenId"		541	\| "TokenId"
	542	\| "NodeId"		542	\| "NodeId"
	543	\| "DefId"		543	\| "DefId"
	544	\| "HirId"		544	\| "HirId"
	545	\| "MirId"		545	\| "MirId"
	546	\| "TypeId"		546	\| "TypeId"
	547	\| "SymbolId"		547	\| "SymbolId"
	548	\| "ScopeId"		548	\| "ScopeId"
	549	\| "BlockId"		549	\| "BlockId"
	550	\| "ValueId"		550	\| "ValueId"
	551	\| "InstrId"		551	\| "InstrId"
	552	;		552	;
	553			553
	554	<<< ================= Literals ================= >>>		554	<<< ================= Literals ================= >>>
	555			555
	556	literal ::= bool_lit		556	literal ::= bool_lit
	557	\| null_lit		557	\| null_lit
	558	\| int_lit		558	\| int_lit
	559	\| float_lit		559	\| float_lit
	560	\| char_lit		560	\| char_lit
	561	\| string_lit		561	\| string_lit
	562	\| list_lit		562	\| list_lit
	563	;		563	;
	564			564
	565	list_lit ::= "[" WS? ( list_comp \| arg_list? ) WS? "]" ;		565	list_lit ::= "[" WS? ( list_comp \| arg_list? ) WS? "]" ;
	566	list_comp ::= expr WS1 "for" WS1 pattern WS1 "in" WS1 expr [ WS1 "if" WS1 expr ] ;		566	list_comp ::= expr WS1 "for" WS1 pattern WS1 "in" WS1 expr [ WS1 "if" WS1 expr ] ;
	567			567
	568	bool_lit ::= "true" \| "false" ;		568	bool_lit ::= "true" \| "false" ;
	569	null_lit ::= "null" ;		569	null_lit ::= "null" ;
	570			570
	571	int_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } [ suffix ]		571	int_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } [ suffix ]
	572	\| [ "-" ] "0x" HEXDIGIT { HEXDIGIT \| "_" } [ suffix ]		572	\| [ "-" ] "0x" HEXDIGIT { HEXDIGIT \| "_" } [ suffix ]
	573	\| [ "-" ] "0b" BINDIGIT { BINDIGIT \| "_" } [ suffix ]		573	\| [ "-" ] "0b" BINDIGIT { BINDIGIT \| "_" } [ suffix ]
	574	\| [ "-" ] "0o" OCTDIGIT { OCTDIGIT \| "_" } [ suffix ]		574	\| [ "-" ] "0o" OCTDIGIT { OCTDIGIT \| "_" } [ suffix ]
	575	;		575	;
	576			576
	577	float_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } "." DIGIT { DIGIT \| "_" } [ exponent ] [ suffix ] ;		577	float_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } "." DIGIT { DIGIT \| "_" } [ exponent ] [ suffix ] ;
	578	exponent ::= ( "e" \| "E" ) [ "+" \| "-" ] DIGIT { DIGIT \| "_" } ;		578	exponent ::= ( "e" \| "E" ) [ "+" \| "-" ] DIGIT { DIGIT \| "_" } ;
	579			579
	580	char_lit ::= "'" char_char "'" ;		580	char_lit ::= "'" char_char "'" ;
	581	char_char ::= escape_seq \| ~"'" ;		581	char_char ::= escape_seq \| ~"'" ;
	582			582
	583	string_lit ::= "\"" { string_char } "\"" \| raw_string_lit ;		583	string_lit ::= "\"" { string_char } "\"" \| raw_string_lit ;
	584	string_char ::= escape_seq \| ~"\"" ;		584	string_char ::= escape_seq \| ~"\"" ;
	585			585
	586	escape_seq ::= "\\n"		586	escape_seq ::= "\\n"
	587	\| "\\r"		587	\| "\\r"
	588	\| "\\t"		588	\| "\\t"
	589	\| "\\0"		589	\| "\\0"
	590	\| "\\\""		590	\| "\\\""
	591	\| "\\'"		591	\| "\\'"
	592	\| "\\\\"		592	\| "\\\\"
	593	\| "\\x" HEXDIGIT HEXDIGIT		593	\| "\\x" HEXDIGIT HEXDIGIT
	594	\| "\\u{" HEXDIGIT { HEXDIGIT } "}"		594	\| "\\u{" HEXDIGIT { HEXDIGIT } "}"
	595	;		595	;
	596			596
	597	raw_string_lit ::= "\"\"\"" { raw_string_char } "\"\"\""		597	raw_string_lit ::= "\"\"\"" { raw_string_char } "\"\"\""
	598	\| "r\"" { raw_string_char } "\""		598	\| "r\"" { raw_string_char } "\""
	599	;		599	;
	600	raw_string_char ::= ~"\"\"\"" ;		600	raw_string_char ::= ~"\"\"\"" ;
	601			601
	602	<<< ================= Lexical ================= >>>		602	<<< ================= Lexical ================= >>>
	603			603
	604	line_comment ::= "#" { ~NEWLINE ANY }		604	line_comment ::= "#" { ~NEWLINE ANY }
	605	\| "//" { ~NEWLINE ANY }		605	\| "//" { ~NEWLINE ANY }
	606	;		606	;
	607			607
	608	block_comment ::= "/" { ~"/" ANY } "*/" ;		608	block_comment ::= "/" { ~"/" ANY } "*/" ;
	609	zone_comment ::= "<<<" { ~">>>" ANY } ">>>" ;		609	zone_comment ::= "<<<" { ~">>>" ANY } ">>>" ;
	610			610
	611	ident ::= ( LETTER \| "_" ) { LETTER \| DIGIT \| "_" } ;		611	ident ::= ( LETTER \| "_" ) { LETTER \| DIGIT \| "_" } ;
	612	suffix ::= LETTER { LETTER \| DIGIT } ;		612	suffix ::= LETTER { LETTER \| DIGIT } ;
	613			613
	614	WS ::= { " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;		614	WS ::= { " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;
	615	WS1 ::= ( " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment )		615	WS1 ::= ( " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment )
	616	{ " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;		616	{ " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;
	617			617
	618	NEWLINE ::= "\n" \| "\r\n" ;		618	NEWLINE ::= "\n" \| "\r\n" ;
	619			619
	620	LETTER ::= "a"..."z" \| "A"..."Z" ;		620	LETTER ::= "a"..."z" \| "A"..."Z" ;
	621	DIGIT ::= "0"..."9" ;		621	DIGIT ::= "0"..."9" ;
	622	BINDIGIT ::= "0" \| "1" ;		622	BINDIGIT ::= "0" \| "1" ;
	623	OCTDIGIT ::= "0"..."7" ;		623	OCTDIGIT ::= "0"..."7" ;
	624	HEXDIGIT ::= DIGIT \| "a"..."f" \| "A"..."F" ;		624	HEXDIGIT ::= DIGIT \| "a"..."f" \| "A"..."F" ;
	625			625
	626	EOF ::= !ANY ;		626	EOF ::= !ANY ;