Grammar Diff (vN vs vN+1)

	vN			vN+1
t	1	<<< =========================================================	t	1	<<< =========================================================
	2	Vitte — Complete Core Grammar		2	Vitte — Complete Core Grammar
	3	systems + application + kernel + compiler surface		3	systems + application + kernel + compiler surface
	4	canonical blocks: { }		4	canonical blocks: { }
	5	canonical syntax source for parser/docs/tests		5	canonical syntax source for parser/docs/tests
	6	low-level capable		6	low-level capable
	7	compiler-capable		7	compiler-capable
	8	no aliases, reduced duplicates		8	no aliases, reduced duplicates
	9	========================================================= >>>		9	========================================================= >>>
	10			10
	11	program ::= WS? { toplevel WS? } EOF ;		11	program ::= WS? { toplevel WS? } EOF ;
	12			12
	13	<<< ================= Top-level ================= >>>		13	<<< ================= Top-level ================= >>>
	14			14
	15	toplevel ::= inner_attribute		15	toplevel ::= inner_attribute
	16	\| space_decl		16	\| space_decl
	17	\| use_decl		17	\| use_decl
	18	\| export_decl		18	\| export_decl
	19	\| const_decl		19	\| const_decl
	20	\| static_decl		20	\| static_decl
	21	\| global_decl		21	\| global_decl
	22	\| type_alias_decl		22	\| type_alias_decl
	23	\| opaque_type_decl		23	\| opaque_type_decl
	24	\| extern_type_decl		24	\| extern_type_decl
	25	\| form_decl		25	\| form_decl
	26	\| class_decl		26	\| class_decl
	27	\| union_decl		27	\| union_decl
	28	\| bits_decl		28	\| bits_decl
	29	\| pick_decl		29	\| pick_decl
	30	\| flags_decl		30	\| flags_decl
	31	\| trait_decl		31	\| trait_decl
	32	\| impl_decl		32	\| impl_decl
	33	\| extern_block		33	\| extern_block
	34	\| proc_decl		34	\| proc_decl
	35	\| intrinsic_decl		35	\| intrinsic_decl
	36	\| compiler_decl		36	\| compiler_decl
	37	\| query_decl		37	\| query_decl
	38	\| pass_decl		38	\| pass_decl
	39	\| backend_decl		39	\| backend_decl
	40	\| diagnostic_decl		40	\| diagnostic_decl
	41	\| macro_decl		41	\| macro_decl
	42	\| comptime_decl		42	\| comptime_decl
	43	\| static_assert_decl		43	\| static_assert_decl
	44	\| test_decl		44	\| test_decl
	45	\| bench_decl		45	\| bench_decl
	46	\| entry_decl		46	\| entry_decl
	47	;		47	;
	48			48
	49	space_decl ::= "space" WS1 module_path ;		49	space_decl ::= "space" WS1 module_path ;
	50			50
	51	use_decl ::= "use" WS1 package_path [ use_group \| use_glob ] [ WS1 "as" WS1 ident ] ;		51	use_decl ::= "use" WS1 package_path [ use_group \| use_glob ] [ WS1 "as" WS1 ident ] ;
	52	use_glob ::= "." "*" ;		52	use_glob ::= "." "*" ;
	53	use_group ::= "." "{" WS? ( "" \| import_items [ WS? "," WS? "" ]? ) WS? "}" ;		53	use_group ::= "." "{" WS? ( "" \| import_items [ WS? "," WS? "" ]? ) WS? "}" ;
	54			54
	55	import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ;		55	import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ;
	56	import_item ::= ident [ WS1 "as" WS1 ident ] ;		56	import_item ::= ident [ WS1 "as" WS1 ident ] ;
	57			57
	58	export_decl ::= "export" WS1 ( "*" \| ident_list \| "{" WS? ident_list WS? "}" ) ;		58	export_decl ::= "export" WS1 ( "*" \| ident_list \| "{" WS? ident_list WS? "}" ) ;
	59			59
	60	const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		60	const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	61	static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		61	static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	62	global_decl ::= { attr_prefix WS? } "global" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		62	global_decl ::= { attr_prefix WS? } "global" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	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_decl ::= { attr_prefix WS? } "macro" WS1 ident "(" WS? macro_param_list? WS? ")" WS? block ;		158	macro_decl ::= { attr_prefix WS? } "macro" WS1 ident "(" WS? macro_param_list? WS? ")" WS? block ;
	159	macro_param_list ::= macro_param { WS? "," WS? macro_param } [ WS? "," ] ;		159	macro_param_list ::= macro_param { WS? "," WS? macro_param } [ WS? "," ] ;
	160	macro_param ::= ident [ WS? ":" WS? macro_kind ] ;		160	macro_param ::= ident [ WS? ":" WS? macro_kind ] ;
	161	macro_kind ::= "expr" \| "stmt" \| "type" \| "ident" \| "block" \| "item" ;		161	macro_kind ::= "expr" \| "stmt" \| "type" \| "ident" \| "block" \| "item" ;
	162			162
	163	comptime_decl ::= "comptime" WS? block ;		163	comptime_decl ::= "comptime" WS? block ;
	164	static_assert_decl ::= "static_assert" WS? "(" WS? expr [ WS? "," WS? expr ] WS? ")" ;		164	static_assert_decl ::= "static_assert" WS? "(" WS? expr [ WS? "," WS? expr ] WS? ")" ;
	165	test_decl ::= { attr_prefix WS? } "test" WS1 string_lit WS? block ;		165	test_decl ::= { attr_prefix WS? } "test" WS1 string_lit WS? block ;
	166	bench_decl ::= { attr_prefix WS? } "bench" WS1 string_lit WS? block ;		166	bench_decl ::= { attr_prefix WS? } "bench" WS1 string_lit WS? block ;
	167	entry_decl ::= { attr_prefix WS? } "entry" WS1 ident WS1 "at" WS1 module_path WS? block ;		167	entry_decl ::= { attr_prefix WS? } "entry" WS1 ident WS1 "at" WS1 module_path WS? block ;
	168			168
	169	visibility ::= "pub" \| "priv" \| "pub" WS? "(" WS? visibility_scope WS? ")" ;		169	visibility ::= "pub" \| "priv" \| "pub" WS? "(" WS? visibility_scope WS? ")" ;
	170	visibility_scope ::= "package" \| "module" \| "super" ;		170	visibility_scope ::= "package" \| "module" \| "super" ;
	171			171
	172	generic_params ::= "[" WS? generic_param_list? WS? "]" ;		172	generic_params ::= "[" WS? generic_param_list? WS? "]" ;
	173	generic_param_list ::= generic_param { WS? "," WS? generic_param } [ WS? "," ] ;		173	generic_param_list ::= generic_param { WS? "," WS? generic_param } [ WS? "," ] ;
	174	generic_param ::= ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ]		174	generic_param ::= ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ]
	175	\| "const" WS1 ident WS? ":" WS? type_expr		175	\| "const" WS1 ident WS? ":" WS? type_expr
	176	\| "comptime" WS1 ident WS? ":" WS? type_expr		176	\| "comptime" WS1 ident WS? ":" WS? type_expr
	177	;		177	;
	178			178
	179	where_clause ::= "where" WS1 where_bounds ;		179	where_clause ::= "where" WS1 where_bounds ;
	180	where_bounds ::= where_bound { WS? "," WS? where_bound } [ WS? "," ] ;		180	where_bounds ::= where_bound { WS? "," WS? where_bound } [ WS? "," ] ;
	181	where_bound ::= type_expr WS? ":" WS? trait_bound		181	where_bound ::= type_expr WS? ":" WS? trait_bound
	182	\| type_expr WS? "==" WS? type_expr		182	\| type_expr WS? "==" WS? type_expr
	183	\| expr WS? rel_op WS? expr		183	\| expr WS? rel_op WS? expr
	184	;		184	;
	185			185
	186	trait_bound ::= type_expr { WS? "+" WS? type_expr } ;		186	trait_bound ::= type_expr { WS? "+" WS? type_expr } ;
	187			187
	188	param_list ::= param { WS? "," WS? param } [ WS? "," ] ;		188	param_list ::= param { WS? "," WS? param } [ WS? "," ] ;
	189	param ::= self_param \| normal_param \| variadic_param ;		189	param ::= self_param \| normal_param \| variadic_param ;
	190	self_param ::= [ "&" WS? ] [ "mut" WS1 ] "self" ;		190	self_param ::= [ "&" WS? ] [ "mut" WS1 ] "self" ;
	191	normal_param ::= [ param_mode WS1 ] pattern [ WS? ":" WS? type_expr ] [ WS? "=" WS? expr ] ;		191	normal_param ::= [ param_mode WS1 ] pattern [ WS? ":" WS? type_expr ] [ WS? "=" WS? expr ] ;
	192	variadic_param ::= "..." \| ident WS? ":" WS? "..." type_expr ;		192	variadic_param ::= "..." \| ident WS? ":" WS? "..." type_expr ;
	193	param_mode ::= "mut" \| "owned" \| "borrow" \| "move" ;		193	param_mode ::= "mut" \| "owned" \| "borrow" \| "move" ;
	194			194
	195	effects_clause ::= "effects" WS? "(" WS? ident_list? WS? ")" ;		195	effects_clause ::= "effects" WS? "(" WS? ident_list? WS? ")" ;
	196	requires_clause ::= "requires" WS? "(" WS? capability_list? WS? ")" ;		196	requires_clause ::= "requires" WS? "(" WS? capability_list? WS? ")" ;
	197	capability_list ::= capability { WS? "," WS? capability } [ WS? "," ] ;		197	capability_list ::= capability { WS? "," WS? capability } [ WS? "," ] ;
	198	capability ::= ident { "." ident } ;		198	capability ::= ident { "." ident } ;
	199			199
	200	module_path ::= relative? package_parts ;		200	module_path ::= relative? package_parts ;
	201	package_path ::= relative? package_parts ;		201	package_path ::= relative? package_parts ;
	202	relative ::= { "." } ;		202	relative ::= { "." } ;
	203	package_parts ::= ident { ( "/" \| "." \| "::" ) ident } ;		203	package_parts ::= ident { ( "/" \| "." \| "::" ) ident } ;
	204	ident_list ::= ident { WS? "," WS? ident } [ WS? "," ] ;		204	ident_list ::= ident { WS? "," WS? ident } [ WS? "," ] ;
	205			205
	206	<<< ================= Compiler Declarations ================= >>>		206	<<< ================= Compiler Declarations ================= >>>
	207			207
	208	compiler_decl ::= { attr_prefix WS? } "compiler" WS1 ident WS? "{" WS? compiler_items? WS? "}" ;		208	compiler_decl ::= { attr_prefix WS? } "compiler" WS1 ident WS? "{" WS? compiler_items? WS? "}" ;
	209	compiler_items ::= compiler_item { WS? compiler_item } ;		209	compiler_items ::= compiler_item { WS? compiler_item } ;
	210			210
	211	compiler_item ::= compiler_phase_decl		211	compiler_item ::= compiler_phase_decl
	212	\| compiler_stage_decl		212	\| compiler_stage_decl
	213	\| compiler_artifact_decl		213	\| compiler_artifact_decl
	214	\| compiler_pipeline_decl		214	\| compiler_pipeline_decl
	215	\| compiler_cache_decl		215	\| compiler_cache_decl
	216	\| compiler_target_decl		216	\| compiler_target_decl
	217	;		217	;
	218			218
	219	compiler_phase_decl ::= "phase" WS1 ident WS? "{" WS?		219	compiler_phase_decl ::= "phase" WS1 ident WS? "{" WS?
	220	"input" WS? ":" WS? type_expr WS? ";"		220	"input" WS? ":" WS? type_expr WS? ";"
	221	"output" WS? ":" WS? type_expr WS? ";"		221	"output" WS? ":" WS? type_expr WS? ";"
	222	[ "errors" WS? ":" WS? type_expr WS? ";" ]		222	[ "errors" WS? ":" WS? type_expr WS? ";" ]
	223	WS? "}" ;		223	WS? "}" ;
	224			224
	225	compiler_stage_decl ::= "stage" WS1 ident WS? ":" WS? ident_list WS? ";" ;		225	compiler_stage_decl ::= "stage" WS1 ident WS? ":" WS? ident_list WS? ";" ;
	226	compiler_artifact_decl ::= "artifact" WS1 ident WS? ":" WS? type_expr WS? ";" ;		226	compiler_artifact_decl ::= "artifact" WS1 ident WS? ":" WS? type_expr WS? ";" ;
	227			227
	228	compiler_pipeline_decl ::= "pipeline" WS1 ident WS? "{" WS? pipeline_step* WS? "}" ;		228	compiler_pipeline_decl ::= "pipeline" WS1 ident WS? "{" WS? pipeline_step* WS? "}" ;
	229	pipeline_step ::= "run" WS1 ident [ WS? "as" WS? ident ] WS? ";"		229	pipeline_step ::= "run" WS1 ident [ WS? "as" WS? ident ] WS? ";"
	230	\| "dump" WS1 ident WS? ";"		230	\| "dump" WS1 ident WS? ";"
	231	\| "verify" WS1 ident WS? ";"		231	\| "verify" WS1 ident WS? ";"
	232	;		232	;
	233			233
	234	compiler_cache_decl ::= "cache" WS1 ident WS? "{" WS? cache_item* WS? "}" ;		234	compiler_cache_decl ::= "cache" WS1 ident WS? "{" WS? cache_item* WS? "}" ;
	235	cache_item ::= "key" WS? ":" WS? type_expr WS? ";"		235	cache_item ::= "key" WS? ":" WS? type_expr WS? ";"
	236	\| "value" WS? ":" WS? type_expr WS? ";"		236	\| "value" WS? ":" WS? type_expr WS? ";"
	237	\| "strategy" WS? ":" WS? ident WS? ";"		237	\| "strategy" WS? ":" WS? ident WS? ";"
	238	;		238	;
	239			239
	240	compiler_target_decl ::= "target" WS1 ident WS? "{" WS? target_item* WS? "}" ;		240	compiler_target_decl ::= "target" WS1 ident WS? "{" WS? target_item* WS? "}" ;
	241	target_item ::= ident WS? ":" WS? expr WS? ";" ;		241	target_item ::= ident WS? ":" WS? expr WS? ";" ;
	242			242
	243	query_decl ::= { attr_prefix WS? } "query" WS1 ident		243	query_decl ::= { attr_prefix WS? } "query" WS1 ident
	244	"(" WS? param_list? WS? ")"		244	"(" WS? param_list? WS? ")"
	245	WS? "->" WS? type_expr		245	WS? "->" WS? type_expr
	246	WS? query_body ;		246	WS? query_body ;
	247			247
	248	query_body ::= block \| ";" ;		248	query_body ::= block \| ";" ;
	249			249
	250	pass_decl ::= { attr_prefix WS? } "pass" WS1 ident WS? "{" WS? pass_items? WS? "}" ;		250	pass_decl ::= { attr_prefix WS? } "pass" WS1 ident WS? "{" WS? pass_items? WS? "}" ;
	251	pass_items ::= pass_item { WS? pass_item } ;		251	pass_items ::= pass_item { WS? pass_item } ;
	252	pass_item ::= "input" WS? ":" WS? type_expr WS? ";"		252	pass_item ::= "input" WS? ":" WS? type_expr WS? ";"
	253	\| "output" WS? ":" WS? type_expr WS? ";"		253	\| "output" WS? ":" WS? type_expr WS? ";"
	254	\| "requires" WS? ":" WS? ident_list WS? ";"		254	\| "requires" WS? ":" WS? ident_list WS? ";"
	255	\| "invalidates" WS? ":" WS? ident_list WS? ";"		255	\| "invalidates" WS? ":" WS? ident_list WS? ";"
	256	\| proc_decl		256	\| proc_decl
	257	;		257	;
	258			258
	259	backend_decl ::= { attr_prefix WS? } "backend" WS1 ident WS? "{" WS? backend_items? WS? "}" ;		259	backend_decl ::= { attr_prefix WS? } "backend" WS1 ident WS? "{" WS? backend_items? WS? "}" ;
	260	backend_items ::= backend_item { WS? backend_item } ;		260	backend_items ::= backend_item { WS? backend_item } ;
	261	backend_item ::= "target" WS? ":" WS? string_lit WS? ";"		261	backend_item ::= "target" WS? ":" WS? string_lit WS? ";"
	262	\| "format" WS? ":" WS? backend_format WS? ";"		262	\| "format" WS? ":" WS? backend_format WS? ";"
	263	\| "emits" WS? ":" WS? backend_output WS? ";"		263	\| "emits" WS? ":" WS? backend_output WS? ";"
	264	\| "requires" WS? ":" WS? ident_list WS? ";"		264	\| "requires" WS? ":" WS? ident_list WS? ";"
	265	\| proc_decl		265	\| proc_decl
	266	;		266	;
	267			267
	268	backend_format ::= "c" \| "llvm" \| "asm" \| "object" \| "wasm" \| "ir" ;		268	backend_format ::= "c" \| "llvm" \| "asm" \| "object" \| "wasm" \| "ir" ;
	269	backend_output ::= "source" \| "assembly" \| "object" \| "executable" \| "library" ;		269	backend_output ::= "source" \| "assembly" \| "object" \| "executable" \| "library" ;
	270			270
	271	diagnostic_decl ::= { attr_prefix WS? } "diagnostic" WS1 diagnostic_code WS? "{" WS? diagnostic_items? WS? "}" ;		271	diagnostic_decl ::= { attr_prefix WS? } "diagnostic" WS1 diagnostic_code WS? "{" WS? diagnostic_items? WS? "}" ;
	272	diagnostic_code ::= ident \| string_lit ;		272	diagnostic_code ::= ident \| string_lit ;
	273	diagnostic_items ::= diagnostic_item { WS? diagnostic_item } ;		273	diagnostic_items ::= diagnostic_item { WS? diagnostic_item } ;
	274			274
	275	diagnostic_item ::= "level" WS? ":" WS? diagnostic_level WS? ";"		275	diagnostic_item ::= "level" WS? ":" WS? diagnostic_level WS? ";"
	276	\| "message" WS? ":" WS? string_lit WS? ";"		276	\| "message" WS? ":" WS? string_lit WS? ";"
	277	\| "label" WS? ":" WS? string_lit WS? ";"		277	\| "label" WS? ":" WS? string_lit WS? ";"
	278	\| "help" WS? ":" WS? string_lit WS? ";"		278	\| "help" WS? ":" WS? string_lit WS? ";"
	279	\| "note" WS? ":" WS? string_lit WS? ";"		279	\| "note" WS? ":" WS? string_lit WS? ";"
	280	\| "suggest" WS? ":" WS? string_lit WS? ";"		280	\| "suggest" WS? ":" WS? string_lit WS? ";"
	281	;		281	;
	282			282
	283	diagnostic_level ::= "error" \| "warning" \| "note" \| "help" \| "fatal" ;		283	diagnostic_level ::= "error" \| "warning" \| "note" \| "help" \| "fatal" ;
	284			284
	285	<<< ================= Attributes ================= >>>		285	<<< ================= Attributes ================= >>>
	286			286
	287	attr_prefix ::= outer_attribute \| doc_comment \| docstring ;		287	attr_prefix ::= outer_attribute \| doc_comment \| docstring ;
	288	inner_attribute ::= "#![" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;		288	inner_attribute ::= "#![" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;
	289	outer_attribute ::= "#[" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;		289	outer_attribute ::= "#[" attr_path [ "(" WS? attr_arg_list? WS? ")" ] "]" ;
	290	doc_comment ::= "///" { ~NEWLINE ANY } ;		290	doc_comment ::= "///" { ~NEWLINE ANY } ;
	291	docstring ::= raw_string_lit ;		291	docstring ::= raw_string_lit ;
	292			292
	293	attr_path ::= ident { "." ident } ;		293	attr_path ::= ident { "." ident } ;
	294	attr_arg_list ::= attr_arg { WS? "," WS? attr_arg } [ WS? "," ] ;		294	attr_arg_list ::= attr_arg { WS? "," WS? attr_arg } [ WS? "," ] ;
	295	attr_arg ::= ident		295	attr_arg ::= ident
	296	\| string_lit		296	\| string_lit
	297	\| int_lit		297	\| int_lit
	298	\| bool_lit		298	\| bool_lit
	299	\| ident WS? "=" WS? literal		299	\| ident WS? "=" WS? literal
	300	;		300	;
	301			301
	302	<<< ================= Blocks / Statements ================= >>>		302	<<< ================= Blocks / Statements ================= >>>
	303			303
	304	block ::= "{" WS? { stmt WS? } "}" ;		304	block ::= "{" WS? { stmt WS? } "}" ;
	305			305
	306	stmt ::= local_const_stmt stmt_end		306	stmt ::= local_const_stmt stmt_end
	307	\| let_stmt stmt_end		307	\| let_stmt stmt_end
	308	\| set_stmt stmt_end		308	\| set_stmt stmt_end
	309	\| give_stmt stmt_end		309	\| give_stmt stmt_end
	310	\| try_stmt stmt_end		310	\| try_stmt stmt_end
	311	\| defer_stmt		311	\| defer_stmt
	312	\| asm_stmt stmt_end		312	\| asm_stmt stmt_end
	313	\| unsafe_stmt		313	\| unsafe_stmt
	314	\| emit_stmt stmt_end		314	\| emit_stmt stmt_end
	315	\| assert_stmt stmt_end		315	\| assert_stmt stmt_end
	316	\| panic_stmt stmt_end		316	\| panic_stmt stmt_end
	317	\| unreachable_stmt stmt_end		317	\| unreachable_stmt stmt_end
	318	\| if_stmt		318	\| if_stmt
	319	\| while_stmt		319	\| while_stmt
	320	\| loop_stmt		320	\| loop_stmt
	321	\| for_stmt		321	\| for_stmt
	322	\| break_stmt stmt_end		322	\| break_stmt stmt_end
	323	\| continue_stmt stmt_end		323	\| continue_stmt stmt_end
	324	\| select_stmt		324	\| select_stmt
	325	\| match_stmt		325	\| match_stmt
	326	\| when_match_stmt		326	\| when_match_stmt
	327	\| with_stmt		327	\| with_stmt
	328	\| critical_stmt		328	\| critical_stmt
	329	\| expr_stmt stmt_end		329	\| expr_stmt stmt_end
	330	;		330	;
	331			331
	332	stmt_end ::= WS? ";" ;		332	stmt_end ::= WS? ";" ;
	333			333
	334	local_const_stmt ::= "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		334	local_const_stmt ::= "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	335	let_stmt ::= "let" WS1 [ "mut" WS1 ] pattern [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;		335	let_stmt ::= "let" WS1 [ "mut" WS1 ] pattern [ WS? ":" WS? type_expr ] WS? "=" WS? expr ;
	336	<<< assign_target stays intentionally syntactic here; projection validity and aliasing		336	<<< assign_target stays intentionally syntactic here; projection validity and aliasing
	337	are enforced later by sema/typeck/borrowck on structured HIR/MIR places. >>>		337	are enforced later by sema/typeck/borrowck on structured HIR/MIR places. >>>
	338	set_stmt ::= "set" WS1 assign_target WS? assign_op WS? expr ;		338	set_stmt ::= "set" WS1 assign_target WS? assign_op WS? expr ;
	339	assign_target ::= unary_expr ;		339	assign_target ::= unary_expr ;
	340			340
	341	give_stmt ::= "give" [ WS1 expr ] ;		341	give_stmt ::= "give" [ WS1 expr ] ;
	342	try_stmt ::= "try" WS1 expr ;		342	try_stmt ::= "try" WS1 expr ;
	343	defer_stmt ::= "defer" WS? block ;		343	defer_stmt ::= "defer" WS? block ;
	344			344
	345	asm_stmt ::= "asm" WS? "(" WS? asm_arg_list? WS? ")" ;		345	asm_stmt ::= "asm" WS? "(" WS? asm_arg_list? WS? ")" ;
	346	asm_arg_list ::= asm_arg { WS? "," WS? asm_arg } [ WS? "," ] ;		346	asm_arg_list ::= asm_arg { WS? "," WS? asm_arg } [ WS? "," ] ;
	347	asm_arg ::= string_lit \| ident WS? "(" WS? arg_list? WS? ")" \| ident WS? ":" WS? expr ;		347	asm_arg ::= string_lit \| ident WS? "(" WS? arg_list? WS? ")" \| ident WS? ":" WS? expr ;
	348			348
	349	unsafe_stmt ::= "unsafe" WS? block ;		349	unsafe_stmt ::= "unsafe" WS? block ;
	350			350
	351	emit_stmt ::= "emit" WS1 expr ;		351	emit_stmt ::= "emit" WS1 expr ;
	352	assert_stmt ::= "assert" WS1 expr [ WS? "," WS? expr ] ;		352	assert_stmt ::= "assert" WS1 expr [ WS? "," WS? expr ] ;
	353	panic_stmt ::= "panic" WS1 expr ;		353	panic_stmt ::= "panic" WS1 expr ;
	354	unreachable_stmt ::= "unreachable" ;		354	unreachable_stmt ::= "unreachable" ;
	355			355
	356	if_stmt ::= "if" WS1 expr WS? block		356	if_stmt ::= "if" WS1 expr WS? block
	357	{ WS? "elif" WS1 expr WS? block }		357	{ WS? "elif" WS1 expr WS? block }
	358	[ WS? "else" WS? block ] ;		358	[ WS? "else" WS? block ] ;
	359			359
	360	while_stmt ::= "while" WS1 expr WS? block ;		360	while_stmt ::= "while" WS1 expr WS? block ;
	361	loop_stmt ::= "loop" WS? block ;		361	loop_stmt ::= "loop" WS? block ;
	362	for_stmt ::= "for" WS1 pattern WS1 "in" WS1 expr WS? block ;		362	for_stmt ::= "for" WS1 pattern WS1 "in" WS1 expr WS? block ;
	363			363
	364	break_stmt ::= "break" [ WS1 expr ] ;		364	break_stmt ::= "break" [ WS1 expr ] ;
	365	continue_stmt ::= "continue" ;		365	continue_stmt ::= "continue" ;
	366			366
	367	select_stmt ::= "select" WS1 expr WS? "{" WS?		367	select_stmt ::= "select" WS1 expr WS? "{" WS?
	368	{ "when" WS1 pattern WS? block WS? }		368	{ "when" WS1 pattern WS? block WS? }
	369	[ "else" WS? block ]		369	[ "else" WS? block ]
	370	WS? "}" ;		370	WS? "}" ;
	371			371
	372	match_stmt ::= "match" WS1 expr WS?		372	match_stmt ::= "match" WS1 expr WS?
	373	"{" WS?		373	"{" WS?
	374	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }		374	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }
	375	[ WS? "else" WS? match_arm_body ]		375	[ WS? "else" WS? match_arm_body ]
	376	WS? "}" ;		376	WS? "}" ;
	377			377
	378	match_arm_body ::= block \| "=>" WS? expr WS? ";" ;		378	match_arm_body ::= block \| "=>" WS? expr WS? ";" ;
	379			379
	380	when_match_stmt ::= "when" WS1 expr WS1 "is" WS1 pattern WS? block ;		380	when_match_stmt ::= "when" WS1 expr WS1 "is" WS1 pattern WS? block ;
	381	with_stmt ::= "with" WS1 expr [ WS1 "as" WS1 pattern ] WS? block ;		381	with_stmt ::= "with" WS1 expr [ WS1 "as" WS1 pattern ] WS? block ;
	382	critical_stmt ::= "critical" WS? block ;		382	critical_stmt ::= "critical" WS? block ;
	383	expr_stmt ::= expr ;		383	expr_stmt ::= expr ;
	384			384
	385	<<< ================= Expressions ================= >>>		385	<<< ================= Expressions ================= >>>
	386			386
	387	expr ::= assign_expr ;		387	expr ::= assign_expr ;
	388			388
	389	assign_expr ::= ternary_expr [ WS? assign_op WS? assign_expr ] ;		389	assign_expr ::= ternary_expr [ WS? assign_op WS? assign_expr ] ;
	390	assign_op ::= "=" \| "+=" \| "-=" \| "*=" \| "/=" \| "%=" \| "&=" \| "\|=" \| "^=" \| "<<=" \| ">>=" ;		390	assign_op ::= "=" \| "+=" \| "-=" \| "*=" \| "/=" \| "%=" \| "&=" \| "\|=" \| "^=" \| "<<=" \| ">>=" ;
	391			391
	392	ternary_expr ::= coalesce_expr [ WS? "?" WS? expr WS? ":" WS? expr ] ;		392	ternary_expr ::= coalesce_expr [ WS? "?" WS? expr WS? ":" WS? expr ] ;
	393	coalesce_expr ::= range_expr { WS? "??" WS? range_expr } ;		393	coalesce_expr ::= range_expr { WS? "??" WS? range_expr } ;
	394	range_expr ::= or_expr [ WS? ( ".." \| "..=" ) WS? or_expr ] ;		394	range_expr ::= or_expr [ WS? ( ".." \| "..=" ) WS? or_expr ] ;
	395			395
	396	or_expr ::= and_expr { WS? ( "or" \| "\|\|" ) WS? and_expr } ;		396	or_expr ::= and_expr { WS? ( "or" \| "\|\|" ) WS? and_expr } ;
	397	and_expr ::= bit_or_expr { WS? ( "and" \| "&&" ) WS? bit_or_expr } ;		397	and_expr ::= bit_or_expr { WS? ( "and" \| "&&" ) WS? bit_or_expr } ;
	398			398
	399	bit_or_expr ::= bit_xor_expr { WS? "\|" WS? bit_xor_expr } ;		399	bit_or_expr ::= bit_xor_expr { WS? "\|" WS? bit_xor_expr } ;
	400	bit_xor_expr ::= bit_and_expr { WS? "^" WS? bit_and_expr } ;		400	bit_xor_expr ::= bit_and_expr { WS? "^" WS? bit_and_expr } ;
	401	bit_and_expr ::= eq_expr { WS? "&" WS? eq_expr } ;		401	bit_and_expr ::= eq_expr { WS? "&" WS? eq_expr } ;
	402			402
	403	eq_expr ::= rel_expr { WS? ( "==" \| "!=" ) WS? rel_expr } ;		403	eq_expr ::= rel_expr { WS? ( "==" \| "!=" ) WS? rel_expr } ;
	404	rel_expr ::= shift_expr { WS? rel_op WS? shift_expr } ;		404	rel_expr ::= shift_expr { WS? rel_op WS? shift_expr } ;
	405	rel_op ::= "<" \| "<=" \| ">" \| ">=" \| "in" \| "not" WS1 "in" ;		405	rel_op ::= "<" \| "<=" \| ">" \| ">=" \| "in" \| "not" WS1 "in" ;
	406			406
	407	shift_expr ::= add_expr { WS? ( "<<" \| ">>" ) WS? add_expr } ;		407	shift_expr ::= add_expr { WS? ( "<<" \| ">>" ) WS? add_expr } ;
	408	add_expr ::= mul_expr { WS? ( "+" \| "-" ) WS? mul_expr } ;		408	add_expr ::= mul_expr { WS? ( "+" \| "-" ) WS? mul_expr } ;
	409	mul_expr ::= cast_expr { WS? ( "*" \| "/" \| "%" ) WS? cast_expr } ;		409	mul_expr ::= cast_expr { WS? ( "*" \| "/" \| "%" ) WS? cast_expr } ;
	410			410
	411	cast_expr ::= unary_expr { WS? ( "as" WS? type_expr \| "is" WS? pattern \| "is" WS1 "not" WS1 pattern ) } ;		411	cast_expr ::= unary_expr { WS? ( "as" WS? type_expr \| "is" WS? pattern \| "is" WS1 "not" WS1 pattern ) } ;
	412			412
	413	<<< unary borrow and move syntax are accepted at parse time; whether a use is		413	<<< unary borrow and move syntax are accepted at parse time; whether a use is
	414	actually a copy or a move is decided later from inferred types. >>>		414	actually a copy or a move is decided later from inferred types. >>>
	415	unary_expr ::= ( "not" \| "-" \| "~" \| "*" \| "&" \| "move" \| "await" ) WS? unary_expr		415	unary_expr ::= ( "not" \| "-" \| "~" \| "*" \| "&" \| "move" \| "await" ) WS? unary_expr
	416	\| postfix_expr		416	\| postfix_expr
	417	;		417	;
	418			418
	419	<<< postfix chains define the full place surface used later by ownership and		419	<<< postfix chains define the full place surface used later by ownership and
	420	borrow analysis: field projection, indexing, call, try and await suffixes. >>>		420	borrow analysis: field projection, indexing, call, try and await suffixes. >>>
	421	postfix_expr ::= primary { call_suffix \| member_suffix \| index_suffix \| try_suffix \| await_suffix } ;		421	postfix_expr ::= primary { call_suffix \| member_suffix \| index_suffix \| try_suffix \| await_suffix } ;
	422	call_suffix ::= "(" WS? arg_list? WS? ")" ;		422	call_suffix ::= "(" WS? arg_list? WS? ")" ;
	423	member_suffix ::= "." ident ;		423	member_suffix ::= "." ident ;
	424	index_suffix ::= "[" WS? index_expr WS? "]" ;		424	index_suffix ::= "[" WS? index_expr WS? "]" ;
	425	try_suffix ::= "?" ;		425	try_suffix ::= "?" ;
	426	await_suffix ::= "." "await" ;		426	await_suffix ::= "." "await" ;
	427			427
	428	index_expr ::= expr \| slice_expr ;		428	index_expr ::= expr \| slice_expr ;
	429	slice_expr ::= [ expr ] ":" [ expr ] [ ":" expr ] ;		429	slice_expr ::= [ expr ] ":" [ expr ] [ ":" expr ] ;
	430			430
	431	primary ::= literal		431	primary ::= literal
	432	\| builtin_expr		432	\| builtin_expr
	433	\| path_expr		433	\| path_expr
	434	\| struct_lit		434	\| struct_lit
	435	\| list_lit		435	\| list_lit
	436	\| tuple_lit		436	\| tuple_lit
	437	\| set_lit		437	\| set_lit
	438	\| map_lit		438	\| map_lit
	439	\| bytes_lit		439	\| bytes_lit
	440	\| resource_lit		440	\| resource_lit
	441	\| if_expr		441	\| if_expr
	442	\| proc_expr		442	\| proc_expr
	443	\| match_expr		443	\| match_expr
	444	\| lambda_expr		444	\| lambda_expr
	445	\| unsafe_expr		445	\| unsafe_expr
	446	\| block		446	\| block
	447	\| "(" WS? expr WS? ")"		447	\| "(" WS? expr WS? ")"
	448	;		448	;
	449			449
	450	path_expr ::= ident { ( "." \| "::" ) ident } ;		450	path_expr ::= ident { ( "." \| "::" ) ident } ;
	451			451
	452	arg_list ::= arg { WS? "," WS? arg } [ WS? "," ] ;		452	arg_list ::= arg { WS? "," WS? arg } [ WS? "," ] ;
	453	arg ::= ident WS? ":" WS? expr \| expr ;		453	arg ::= ident WS? ":" WS? expr \| expr ;
	454			454
	455	tuple_lit ::= "(" WS? expr WS? "," WS? expr { WS? "," WS? expr } [ WS? "," ] WS? ")" ;		455	tuple_lit ::= "(" WS? expr WS? "," WS? expr { WS? "," WS? expr } [ WS? "," ] WS? ")" ;
	456	set_lit ::= "set" WS? "{" WS? arg_list? WS? "}" ;		456	set_lit ::= "set" WS? "{" WS? arg_list? WS? "}" ;
	457			457
	458	map_lit ::= "map" WS? "{" WS? map_items? WS? "}" ;		458	map_lit ::= "map" WS? "{" WS? map_items? WS? "}" ;
	459	map_items ::= map_item { WS? "," WS? map_item } [ WS? "," ] ;		459	map_items ::= map_item { WS? "," WS? map_item } [ WS? "," ] ;
	460	map_item ::= expr WS? ":" WS? expr ;		460	map_item ::= expr WS? ":" WS? expr ;
	461			461
	462	bytes_lit ::= "b" string_lit ;		462	bytes_lit ::= "b" string_lit ;
	463			463
	464	resource_lit ::= "resource" WS? "{" WS? resource_items? WS? "}" ;		464	resource_lit ::= "resource" WS? "{" WS? resource_items? WS? "}" ;
	465	resource_items ::= resource_item { WS? "," WS? resource_item } [ WS? "," ] ;		465	resource_items ::= resource_item { WS? "," WS? resource_item } [ WS? "," ] ;
	466	resource_item ::= ident WS? ":" WS? expr ;		466	resource_item ::= ident WS? ":" WS? expr ;
	467			467
	468	struct_lit ::= type_path WS? "{" WS? field_init_list? WS? "}" ;		468	struct_lit ::= type_path WS? "{" WS? field_init_list? WS? "}" ;
	469	type_path ::= ident { ( "." \| "::" ) ident } ;		469	type_path ::= ident { ( "." \| "::" ) ident } ;
	470	field_init_list ::= field_init { WS? "," WS? field_init } [ WS? "," ] ;		470	field_init_list ::= field_init { WS? "," WS? field_init } [ WS? "," ] ;
	471	field_init ::= ident WS? ":" WS? expr		471	field_init ::= ident WS? ":" WS? expr
	472	\| ident		472	\| ident
	473	\| ".." expr		473	\| ".." expr
	474	;		474	;
	475			475
	476	if_expr ::= "if" WS1 expr WS? block		476	if_expr ::= "if" WS1 expr WS? block
	477	{ WS? "elif" WS1 expr WS? block }		477	{ WS? "elif" WS1 expr WS? block }
	478	[ WS? "else" WS? block ] ;		478	[ WS? "else" WS? block ] ;
	479			479
	480	proc_expr ::= { attr_prefix WS? } proc_modifier* "proc" WS? "(" WS? param_list? WS? ")"		480	proc_expr ::= { attr_prefix WS? } proc_modifier* "proc" WS? "(" WS? param_list? WS? ")"
	481	[ WS? "->" WS? type_expr ]		481	[ WS? "->" WS? type_expr ]
	482	WS? proc_suffix*		482	WS? proc_suffix*
	483	WS? block ;		483	WS? block ;
	484			484
	485	match_expr ::= "match" WS1 expr WS?		485	match_expr ::= "match" WS1 expr WS?
	486	"{" WS?		486	"{" WS?
	487	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }		487	{ "case" WS1 pattern [ WS1 "if" WS1 expr ] WS? match_arm_body WS? }
	488	[ WS? "else" WS? match_arm_body ]		488	[ WS? "else" WS? match_arm_body ]
	489	WS? "}" ;		489	WS? "}" ;
	490			490
	491	lambda_expr ::= "\|" WS? param_list? WS? "\|" WS? ( expr \| block ) ;		491	lambda_expr ::= "\|" WS? param_list? WS? "\|" WS? ( expr \| block ) ;
	492	unsafe_expr ::= "unsafe" WS? block ;		492	unsafe_expr ::= "unsafe" WS? block ;
	493			493
	494	builtin_expr ::= sizeof_expr \| alignof_expr \| offsetof_expr \| typeof_expr \| nameof_expr ;		494	builtin_expr ::= sizeof_expr \| alignof_expr \| offsetof_expr \| typeof_expr \| nameof_expr ;
	495	sizeof_expr ::= "sizeof" WS? "(" WS? ( type_expr \| expr ) WS? ")" ;		495	sizeof_expr ::= "sizeof" WS? "(" WS? ( type_expr \| expr ) WS? ")" ;
	496	alignof_expr ::= "alignof" WS? "(" WS? type_expr WS? ")" ;		496	alignof_expr ::= "alignof" WS? "(" WS? type_expr WS? ")" ;
	497	offsetof_expr ::= "offsetof" WS? "(" WS? type_expr WS? "," WS? ident WS? ")" ;		497	offsetof_expr ::= "offsetof" WS? "(" WS? type_expr WS? "," WS? ident WS? ")" ;
	498	typeof_expr ::= "typeof" WS? "(" WS? expr WS? ")" ;		498	typeof_expr ::= "typeof" WS? "(" WS? expr WS? ")" ;
	499	nameof_expr ::= "nameof" WS? "(" WS? path_expr WS? ")" ;		499	nameof_expr ::= "nameof" WS? "(" WS? path_expr WS? ")" ;
	500			500
	501	<<< ================= Patterns ================= >>>		501	<<< ================= Patterns ================= >>>
	502			502
	503	pattern ::= pattern_or ;		503	pattern ::= pattern_or ;
	504	pattern_or ::= pattern_atom { WS? "\|" WS? pattern_atom } ;		504	pattern_or ::= pattern_atom { WS? "\|" WS? pattern_atom } ;
	505			505
	506	pattern_atom ::= "_"		506	pattern_atom ::= "_"
	507	\| literal		507	\| literal
	508	\| "mut" WS1 pattern_bind		508	\| "mut" WS1 pattern_bind
	509	\| "ref" WS1 pattern_bind		509	\| "ref" WS1 pattern_bind
	510	\| pattern_bind		510	\| pattern_bind
	511	\| pattern_ctor		511	\| pattern_ctor
	512	\| pattern_struct		512	\| pattern_struct
	513	\| pattern_tuple		513	\| pattern_tuple
	514	\| pattern_list		514	\| pattern_list
	515	\| pattern_range		515	\| pattern_range
	516	;		516	;
	517			517
	518	pattern_bind ::= ident ;		518	pattern_bind ::= ident ;
	519	pattern_ctor ::= pattern_head [ "(" WS? pattern_args? WS? ")" ] ;		519	pattern_ctor ::= pattern_head [ "(" WS? pattern_args? WS? ")" ] ;
	520	pattern_head ::= ident { ( "." \| "::" ) ident } ;		520	pattern_head ::= ident { ( "." \| "::" ) ident } ;
	521	pattern_args ::= pattern { WS? "," WS? pattern } [ WS? "," ] ;		521	pattern_args ::= pattern { WS? "," WS? pattern } [ WS? "," ] ;
	522			522
	523	pattern_struct ::= pattern_head WS? "{" WS? pattern_fields? WS? "}" ;		523	pattern_struct ::= pattern_head WS? "{" WS? pattern_fields? WS? "}" ;
	524	pattern_fields ::= pattern_field { WS? "," WS? pattern_field } [ WS? "," ] ;		524	pattern_fields ::= pattern_field { WS? "," WS? pattern_field } [ WS? "," ] ;
	525	pattern_field ::= ident [ WS? ":" WS? pattern ] \| ".." ;		525	pattern_field ::= ident [ WS? ":" WS? pattern ] \| ".." ;
	526			526
	527	pattern_tuple ::= "(" WS? pattern WS? "," WS? pattern { WS? "," WS? pattern } [ WS? "," ] WS? ")" ;		527	pattern_tuple ::= "(" WS? pattern WS? "," WS? pattern { WS? "," WS? pattern } [ WS? "," ] WS? ")" ;
	528	pattern_list ::= "[" WS? pattern_args? WS? "]" ;		528	pattern_list ::= "[" WS? pattern_args? WS? "]" ;
	529	pattern_range ::= literal WS? ( ".." \| "..=" ) WS? literal ;		529	pattern_range ::= literal WS? ( ".." \| "..=" ) WS? literal ;
	530			530
	531	<<< ================= Types ================= >>>		531	<<< ================= Types ================= >>>
	532			532
	533	type_expr ::= type_union ;		533	type_expr ::= type_union ;
	534			534
	535	type_union ::= type_prefix { WS? "\|" WS? type_prefix } ;		535	type_union ::= type_prefix { WS? "\|" WS? type_prefix } ;
	536			536
	537	type_prefix ::= type_qualifier* type_atom ;		537	type_prefix ::= type_qualifier* type_atom ;
	538	type_qualifier ::= type_qual WS1 \| addr_space WS1 ;		538	type_qualifier ::= type_qual WS1 \| addr_space WS1 ;
	539			539
	540	type_qual ::= "const" \| "volatile" \| "atomic" \| "mut" \| "owned" \| "borrow" ;		540	type_qual ::= "const" \| "volatile" \| "atomic" \| "mut" \| "owned" \| "borrow" ;
	541	addr_space ::= "user" \| "kernel" \| "phys" \| "mmio" \| "dma" ;		541	addr_space ::= "user" \| "kernel" \| "phys" \| "mmio" \| "dma" ;
	542			542
	543	type_atom ::= reference_type		543	type_atom ::= reference_type
	544	\| pointer_type		544	\| pointer_type
	545	\| optional_type		545	\| optional_type
	546	\| fixed_array_type		546	\| fixed_array_type
	547	\| slice_type		547	\| slice_type
	548	\| tuple_type		548	\| tuple_type
	549	\| proc_type		549	\| proc_type
	550	\| dyn_type		550	\| dyn_type
	551	\| impl_trait_type		551	\| impl_trait_type
	552	\| type_primary		552	\| type_primary
	553	;		553	;
	554			554
	555	<<< shared and mutable references are part of the core surface grammar; lifetime,		555	<<< shared and mutable references are part of the core surface grammar; lifetime,
	556	aliasing and region closure remain semantic checks outside the parser. >>>		556	aliasing and region closure remain semantic checks outside the parser. >>>
	557	reference_type ::= "&" WS? [ lifetime WS? ] [ "mut" WS1 ] type_expr ;		557	reference_type ::= "&" WS? [ lifetime WS? ] [ "mut" WS1 ] type_expr ;
	558	pointer_type ::= "*" WS? [ "const" WS1 \| "mut" WS1 \| "volatile" WS1 \| addr_space WS1 ] type_expr ;		558	pointer_type ::= "*" WS? [ "const" WS1 \| "mut" WS1 \| "volatile" WS1 \| addr_space WS1 ] type_expr ;
	559	optional_type ::= "?" WS? type_expr ;		559	optional_type ::= "?" WS? type_expr ;
	560			560
	561	fixed_array_type ::= "[" WS? type_expr WS? ";" WS? expr WS? "]" ;		561	fixed_array_type ::= "[" WS? type_expr WS? ";" WS? expr WS? "]" ;
	562	slice_type ::= "[" WS? type_expr WS? "]" ;		562	slice_type ::= "[" WS? type_expr WS? "]" ;
	563			563
	564	tuple_type ::= "(" WS? type_expr WS? "," WS? type_expr { WS? "," WS? type_expr } [ WS? "," ] WS? ")" ;		564	tuple_type ::= "(" WS? type_expr WS? "," WS? type_expr { WS? "," WS? type_expr } [ WS? "," ] WS? ")" ;
	565	proc_type ::= "proc" WS? "(" WS? type_list? WS? ")" [ WS? "->" WS? type_expr ] ;		565	proc_type ::= "proc" WS? "(" WS? type_list? WS? ")" [ WS? "->" WS? type_expr ] ;
	566			566
	567	type_list ::= type_param { WS? "," WS? type_param } [ WS? "," ] ;		567	type_list ::= type_param { WS? "," WS? type_param } [ WS? "," ] ;
	568	type_param ::= ident WS? ":" WS? type_expr \| type_expr ;		568	type_param ::= ident WS? ":" WS? type_expr \| type_expr ;
	569			569
	570	dyn_type ::= "dyn" WS1 trait_bound ;		570	dyn_type ::= "dyn" WS1 trait_bound ;
	571	impl_trait_type ::= "impl" WS1 trait_bound ;		571	impl_trait_type ::= "impl" WS1 trait_bound ;
	572			572
	573	type_primary ::= type_path [ "[" WS? type_list? WS? "]" ]		573	type_primary ::= type_path [ "[" WS? type_list? WS? "]" ]
	574	\| primitive_type		574	\| primitive_type
	575	\| "Self"		575	\| "Self"
	576	;		576	;
	577			577
	578	lifetime ::= "'" ident ;		578	lifetime ::= "'" ident ;
	579			579
	580	primitive_type ::= "void"		580	primitive_type ::= "void"
	581	\| "never"		581	\| "never"
	582	\| "unit"		582	\| "unit"
	583	\| "bool"		583	\| "bool"
	584	\| "char"		584	\| "char"
	585	\| "rune"		585	\| "rune"
	586	\| "str"		586	\| "str"
	587	\| "string"		587	\| "string"
	588	\| "bytes"		588	\| "bytes"
	589	\| "cstr"		589	\| "cstr"
	590	\| "int"		590	\| "int"
	591	\| "i8" \| "i16" \| "i32" \| "i64" \| "i128"		591	\| "i8" \| "i16" \| "i32" \| "i64" \| "i128"
	592	\| "u8" \| "u16" \| "u32" \| "u64" \| "u128"		592	\| "u8" \| "u16" \| "u32" \| "u64" \| "u128"
	593	\| "usize" \| "isize"		593	\| "usize" \| "isize"
	594	\| "intptr" \| "uintptr"		594	\| "intptr" \| "uintptr"
	595	\| "f16" \| "f32" \| "f64" \| "f128"		595	\| "f16" \| "f32" \| "f64" \| "f128"
	596	\| "c_char" \| "c_int" \| "c_uint" \| "c_long" \| "c_ulong" \| "c_void"		596	\| "c_char" \| "c_int" \| "c_uint" \| "c_long" \| "c_ulong" \| "c_void"
	597	\| "TokenId"		597	\| "TokenId"
	598	\| "NodeId"		598	\| "NodeId"
	599	\| "DefId"		599	\| "DefId"
	600	\| "HirId"		600	\| "HirId"
	601	\| "MirId"		601	\| "MirId"
	602	\| "TypeId"		602	\| "TypeId"
	603	\| "SymbolId"		603	\| "SymbolId"
	604	\| "ScopeId"		604	\| "ScopeId"
	605	\| "BlockId"		605	\| "BlockId"
	606	\| "ValueId"		606	\| "ValueId"
	607	\| "InstrId"		607	\| "InstrId"
	608	;		608	;
	609			609
	610	<<< ================= Literals ================= >>>		610	<<< ================= Literals ================= >>>
	611			611
	612	literal ::= bool_lit		612	literal ::= bool_lit
	613	\| null_lit		613	\| null_lit
	614	\| int_lit		614	\| int_lit
	615	\| float_lit		615	\| float_lit
	616	\| char_lit		616	\| char_lit
	617	\| string_lit		617	\| string_lit
	618	\| list_lit		618	\| list_lit
	619	;		619	;
	620			620
	621	list_lit ::= "[" WS? ( list_comp \| arg_list? ) WS? "]" ;		621	list_lit ::= "[" WS? ( list_comp \| arg_list? ) WS? "]" ;
	622	list_comp ::= expr WS1 "for" WS1 pattern WS1 "in" WS1 expr [ WS1 "if" WS1 expr ] ;		622	list_comp ::= expr WS1 "for" WS1 pattern WS1 "in" WS1 expr [ WS1 "if" WS1 expr ] ;
	623			623
	624	bool_lit ::= "true" \| "false" ;		624	bool_lit ::= "true" \| "false" ;
	625	null_lit ::= "null" ;		625	null_lit ::= "null" ;
	626			626
	627	int_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } [ suffix ]		627	int_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } [ suffix ]
	628	\| [ "-" ] "0x" HEXDIGIT { HEXDIGIT \| "_" } [ suffix ]		628	\| [ "-" ] "0x" HEXDIGIT { HEXDIGIT \| "_" } [ suffix ]
	629	\| [ "-" ] "0b" BINDIGIT { BINDIGIT \| "_" } [ suffix ]		629	\| [ "-" ] "0b" BINDIGIT { BINDIGIT \| "_" } [ suffix ]
	630	\| [ "-" ] "0o" OCTDIGIT { OCTDIGIT \| "_" } [ suffix ]		630	\| [ "-" ] "0o" OCTDIGIT { OCTDIGIT \| "_" } [ suffix ]
	631	;		631	;
	632			632
	633	float_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } "." DIGIT { DIGIT \| "_" } [ exponent ] [ suffix ] ;		633	float_lit ::= [ "-" ] DIGIT { DIGIT \| "_" } "." DIGIT { DIGIT \| "_" } [ exponent ] [ suffix ] ;
	634	exponent ::= ( "e" \| "E" ) [ "+" \| "-" ] DIGIT { DIGIT \| "_" } ;		634	exponent ::= ( "e" \| "E" ) [ "+" \| "-" ] DIGIT { DIGIT \| "_" } ;
	635			635
	636	char_lit ::= "'" char_char "'" ;		636	char_lit ::= "'" char_char "'" ;
	637	char_char ::= escape_seq \| ~"'" ;		637	char_char ::= escape_seq \| ~"'" ;
	638			638
	639	string_lit ::= "\"" { string_char } "\"" \| raw_string_lit ;		639	string_lit ::= "\"" { string_char } "\"" \| raw_string_lit ;
	640	string_char ::= escape_seq \| ~"\"" ;		640	string_char ::= escape_seq \| ~"\"" ;
	641			641
	642	escape_seq ::= "\\n"		642	escape_seq ::= "\\n"
	643	\| "\\r"		643	\| "\\r"
	644	\| "\\t"		644	\| "\\t"
	645	\| "\\0"		645	\| "\\0"
	646	\| "\\\""		646	\| "\\\""
	647	\| "\\'"		647	\| "\\'"
	648	\| "\\\\"		648	\| "\\\\"
	649	\| "\\x" HEXDIGIT HEXDIGIT		649	\| "\\x" HEXDIGIT HEXDIGIT
	650	\| "\\u{" HEXDIGIT { HEXDIGIT } "}"		650	\| "\\u{" HEXDIGIT { HEXDIGIT } "}"
	651	;		651	;
	652			652
	653	raw_string_lit ::= "\"\"\"" { raw_string_char } "\"\"\""		653	raw_string_lit ::= "\"\"\"" { raw_string_char } "\"\"\""
	654	\| "r\"" { raw_string_char } "\""		654	\| "r\"" { raw_string_char } "\""
	655	;		655	;
	656	raw_string_char ::= ~"\"\"\"" ;		656	raw_string_char ::= ~"\"\"\"" ;
	657			657
	658	<<< ================= Lexical ================= >>>		658	<<< ================= Lexical ================= >>>
	659			659
	660	line_comment ::= "#" { ~NEWLINE ANY }		660	line_comment ::= "#" { ~NEWLINE ANY }
	661	\| "//" { ~NEWLINE ANY }		661	\| "//" { ~NEWLINE ANY }
	662	;		662	;
	663			663
	664	block_comment ::= "/" { ~"/" ANY } "*/" ;		664	block_comment ::= "/" { ~"/" ANY } "*/" ;
	665	zone_comment ::= "<<<" { ~">>>" ANY } ">>>" ;		665	zone_comment ::= "<<<" { ~">>>" ANY } ">>>" ;
	666			666
	667	ident ::= ( LETTER \| "_" ) { LETTER \| DIGIT \| "_" } ;		667	ident ::= ( LETTER \| "_" ) { LETTER \| DIGIT \| "_" } ;
	668	suffix ::= LETTER { LETTER \| DIGIT } ;		668	suffix ::= LETTER { LETTER \| DIGIT } ;
	669			669
	670	WS ::= { " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;		670	WS ::= { " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;
	671	WS1 ::= ( " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment )		671	WS1 ::= ( " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment )
	672	{ " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;		672	{ " " \| "\t" \| NEWLINE \| line_comment \| block_comment \| zone_comment } ;
	673			673
	674	NEWLINE ::= "\n" \| "\r\n" ;		674	NEWLINE ::= "\n" \| "\r\n" ;
	675			675
	676	LETTER ::= "a"..."z" \| "A"..."Z" ;		676	LETTER ::= "a"..."z" \| "A"..."Z" ;
	677	DIGIT ::= "0"..."9" ;		677	DIGIT ::= "0"..."9" ;
	678	BINDIGIT ::= "0" \| "1" ;		678	BINDIGIT ::= "0" \| "1" ;
	679	OCTDIGIT ::= "0"..."7" ;		679	OCTDIGIT ::= "0"..."7" ;
	680	HEXDIGIT ::= DIGIT \| "a"..."f" \| "A"..."F" ;		680	HEXDIGIT ::= DIGIT \| "a"..."f" \| "A"..."F" ;
	681			681
	682	EOF ::= !ANY ;		682	EOF ::= !ANY ;