{
  "version": "v3",
  "checksum": "4493876f55f9d93e4b5dd3dccc15a337693deb68955e9952648866ba8a8230f6",
  "built_at": "2026-06-06T13:11:50.876912+00:00",
  "source": "src/vitte/grammar/vitte.ebnf",
  "rules": [
    {
      "name": "program",
      "body": "WS? { toplevel WS? } EOF ;\n\n<<< ================= Top-level ================= >>>",
      "tests": []
    },
    {
      "name": "toplevel",
      "body": "inner_attribute\n          | space_decl\n          | use_decl\n          | export_decl\n          | const_decl\n          | static_decl\n          | global_decl\n          | type_alias_decl\n          | opaque_type_decl\n          | extern_type_decl\n          | form_decl\n          | class_decl\n          | union_decl\n          | bits_decl\n          | pick_decl\n          | flags_decl\n          | trait_decl\n          | impl_decl\n          | extern_block\n          | proc_decl\n          | intrinsic_decl\n          | compiler_decl\n          | query_decl\n          | pass_decl\n          | backend_decl\n          | diagnostic_decl\n          | macro_decl\n          | comptime_decl\n          | static_assert_decl\n          | test_decl\n          | bench_decl\n          | entry_decl\n          ;",
      "tests": []
    },
    {
      "name": "space_decl",
      "body": "\"space\" WS1 module_path ;",
      "tests": []
    },
    {
      "name": "use_decl",
      "body": "\"use\" WS1 package_path [ use_group | use_glob ] [ WS1 \"as\" WS1 ident ] ;",
      "tests": []
    },
    {
      "name": "use_glob",
      "body": "\".\" \"*\" ;",
      "tests": []
    },
    {
      "name": "use_group",
      "body": "\".\" \"{\" WS? ( \"*\" | import_items [ WS? \",\" WS? \"*\" ]? ) WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "import_items",
      "body": "import_item { WS? \",\" WS? import_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "import_item",
      "body": "ident [ WS1 \"as\" WS1 ident ] ;",
      "tests": []
    },
    {
      "name": "export_decl",
      "body": "\"export\" WS1 ( \"*\" | ident_list | \"{\" WS? ident_list WS? \"}\" ) ;",
      "tests": []
    },
    {
      "name": "const_decl",
      "body": "{ attr_prefix WS? } \"const\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"=\" WS? expr ;",
      "tests": []
    },
    {
      "name": "static_decl",
      "body": "{ attr_prefix WS? } \"static\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"=\" WS? expr ;",
      "tests": []
    },
    {
      "name": "global_decl",
      "body": "{ attr_prefix WS? } \"global\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"=\" WS? expr ;",
      "tests": []
    },
    {
      "name": "type_alias_decl",
      "body": "{ attr_prefix WS? } \"type\" WS1 ident [ generic_params ] WS? \"=\" WS? type_expr ;",
      "tests": []
    },
    {
      "name": "opaque_type_decl",
      "body": "{ attr_prefix WS? } \"opaque\" WS1 \"type\" WS1 ident [ generic_params ] [ WS? \"=\" WS? type_expr ] ;",
      "tests": []
    },
    {
      "name": "extern_type_decl",
      "body": "{ attr_prefix WS? } \"extern\" WS1 \"type\" WS1 ident [ generic_params ] [ WS? \";\" ] ;",
      "tests": []
    },
    {
      "name": "form_decl",
      "body": "{ attr_prefix WS? } \"form\" WS1 ident [ generic_params ] [ WS? where_clause ] WS? \"{\" WS? form_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "class_decl",
      "body": "{ attr_prefix WS? } \"class\" WS1 ident [ generic_params ] [ WS? where_clause ] WS? \"{\" WS? class_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "union_decl",
      "body": "{ attr_prefix WS? } \"union\" WS1 ident [ generic_params ] [ WS? where_clause ] WS? \"{\" WS? field_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "form_items",
      "body": "form_item { WS? \",\"? WS? form_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "form_item",
      "body": "field_item | const_decl | type_alias_decl | proc_decl ;",
      "tests": []
    },
    {
      "name": "class_items",
      "body": "class_item { WS? \",\"? WS? class_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "class_item",
      "body": "field_item | const_decl | type_alias_decl | proc_decl ;",
      "tests": []
    },
    {
      "name": "field_list",
      "body": "field_item { WS? \",\" WS? field_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "field_item",
      "body": "{ attr_prefix WS? } [ visibility WS1 ] ident WS? \":\" WS? type_expr [ WS? \"=\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "bits_decl",
      "body": "{ attr_prefix WS? } \"bits\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"{\" WS? bitfield_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "bitfield_list",
      "body": "bitfield_item { WS? \",\" WS? bitfield_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "bitfield_item",
      "body": "ident WS? \":\" WS? expr WS? \"..\" WS? expr ;",
      "tests": []
    },
    {
      "name": "pick_decl",
      "body": "{ attr_prefix WS? } \"pick\" WS1 ident [ generic_params ] [ WS? \":\" WS? type_expr ] [ WS? where_clause ] WS? \"{\" WS? case_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "case_list",
      "body": "case_item { WS? \",\" WS? case_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "case_item",
      "body": "[ \"case\" WS1 ] ident [ \"(\" WS? case_payload? WS? \")\" ] [ WS? \"=\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "case_payload",
      "body": "case_field { WS? \",\" WS? case_field } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "case_field",
      "body": "ident WS? \":\" WS? type_expr | type_expr ;",
      "tests": []
    },
    {
      "name": "flags_decl",
      "body": "{ attr_prefix WS? } \"flags\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"{\" WS? flag_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "flag_list",
      "body": "flag_item { WS? \",\" WS? flag_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "flag_item",
      "body": "ident [ WS? \"=\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "trait_decl",
      "body": "{ attr_prefix WS? } [ \"unsafe\" WS1 ] \"trait\" WS1 ident [ generic_params ] [ WS? where_clause ] WS? \"{\" WS? trait_item* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "trait_item",
      "body": "proc_signature | const_decl | associated_type_decl ;",
      "tests": []
    },
    {
      "name": "associated_type_decl",
      "body": "\"type\" WS1 ident [ WS? \":\" WS? trait_bound ] [ WS? \"=\" WS? type_expr ] ;",
      "tests": []
    },
    {
      "name": "impl_decl",
      "body": "{ attr_prefix WS? } [ \"unsafe\" WS1 ] \"impl\" WS1 impl_head [ WS? where_clause ] WS? \"{\" WS? impl_item* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "impl_head",
      "body": "type_expr | type_expr WS1 \"for\" WS1 type_expr ;",
      "tests": []
    },
    {
      "name": "impl_item",
      "body": "const_decl | type_alias_decl | associated_type_decl | proc_decl ;",
      "tests": []
    },
    {
      "name": "proc_signature",
      "body": "{ attr_prefix WS? } \"proc\" WS1 ident [ generic_params ]\n                   \"(\" WS? param_list? WS? \")\"\n                   [ WS? \"->\" WS? type_expr ]\n                   WS? proc_suffix*\n                   WS? \";\"\n                   ;",
      "tests": []
    },
    {
      "name": "proc_decl",
      "body": "{ attr_prefix WS? } [ visibility WS1 ] proc_modifier* [ extern_clause WS1 ] \"proc\" WS1 proc_name [ generic_params ]\n              \"(\" WS? param_list? WS? \")\"\n              [ WS? \"->\" WS? type_expr ]\n              WS? proc_suffix*\n              WS? ( block | \";\" )\n              ;",
      "tests": []
    },
    {
      "name": "proc_name",
      "body": "ident | \"operator\" WS? operator_symbol ;",
      "tests": []
    },
    {
      "name": "operator_symbol",
      "body": "\"+\" | \"-\" | \"*\" | \"/\" | \"%\"\n                  | \"==\" | \"!=\" | \"<\" | \"<=\" | \">\" | \">=\"\n                  | \"[]\" | \"()\" ;",
      "tests": []
    },
    {
      "name": "proc_modifier",
      "body": "\"async\" WS1\n                | \"unsafe\" WS1\n                | \"const\" WS1\n                | \"inline\" WS1\n                | \"noinline\" WS1\n                | \"naked\" WS1\n                | \"interrupt\" WS1\n                ;",
      "tests": []
    },
    {
      "name": "proc_suffix",
      "body": "effects_clause\n              | requires_clause\n              | where_clause\n              | \"noexcept\"\n              ;",
      "tests": []
    },
    {
      "name": "extern_block",
      "body": "{ attr_prefix WS? } \"extern\" WS1 extern_abi WS? \"{\" WS? extern_item* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "extern_item",
      "body": "extern_proc_decl | extern_type_decl | const_decl ;",
      "tests": []
    },
    {
      "name": "extern_proc_decl",
      "body": "{ attr_prefix WS? } \"proc\" WS1 ident [ generic_params ]\n                     \"(\" WS? param_list? WS? \")\"\n                     [ WS? \"->\" WS? type_expr ]\n                     WS? proc_suffix*\n                     WS? \";\"\n                     ;",
      "tests": []
    },
    {
      "name": "extern_clause",
      "body": "\"extern\" WS1 extern_abi ;",
      "tests": []
    },
    {
      "name": "extern_abi",
      "body": "callconv | string_lit ;",
      "tests": []
    },
    {
      "name": "callconv",
      "body": "\"C\" | \"sysv64\" | \"win64\" | \"interrupt\" | \"naked\" ;",
      "tests": []
    },
    {
      "name": "intrinsic_decl",
      "body": "{ attr_prefix WS? } \"intrinsic\" WS1 ident [ generic_params ]\n                   \"(\" WS? param_list? WS? \")\"\n                   [ WS? \"->\" WS? type_expr ]\n                   WS? \";\"\n                   ;",
      "tests": []
    },
    {
      "name": "macro_decl",
      "body": "{ attr_prefix WS? } \"macro\" WS1 ident \"(\" WS? macro_param_list? WS? \")\" WS? block ;",
      "tests": []
    },
    {
      "name": "macro_param_list",
      "body": "macro_param { WS? \",\" WS? macro_param } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "macro_param",
      "body": "ident [ WS? \":\" WS? macro_kind ] ;",
      "tests": []
    },
    {
      "name": "macro_kind",
      "body": "\"expr\" | \"stmt\" | \"type\" | \"ident\" | \"block\" | \"item\" ;",
      "tests": []
    },
    {
      "name": "comptime_decl",
      "body": "\"comptime\" WS? block ;",
      "tests": []
    },
    {
      "name": "static_assert_decl",
      "body": "\"static_assert\" WS? \"(\" WS? expr [ WS? \",\" WS? expr ] WS? \")\" ;",
      "tests": []
    },
    {
      "name": "test_decl",
      "body": "{ attr_prefix WS? } \"test\" WS1 string_lit WS? block ;",
      "tests": []
    },
    {
      "name": "bench_decl",
      "body": "{ attr_prefix WS? } \"bench\" WS1 string_lit WS? block ;",
      "tests": []
    },
    {
      "name": "entry_decl",
      "body": "{ attr_prefix WS? } \"entry\" WS1 ident WS1 \"at\" WS1 module_path WS? block ;",
      "tests": []
    },
    {
      "name": "visibility",
      "body": "\"pub\" | \"priv\" | \"pub\" WS? \"(\" WS? visibility_scope WS? \")\" ;",
      "tests": []
    },
    {
      "name": "visibility_scope",
      "body": "\"package\" | \"module\" | \"super\" ;",
      "tests": []
    },
    {
      "name": "generic_params",
      "body": "\"[\" WS? generic_param_list? WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "generic_param_list",
      "body": "generic_param { WS? \",\" WS? generic_param } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "generic_param",
      "body": "ident [ WS? \":\" WS? trait_bound ] [ WS? \"=\" WS? type_expr ]\n                | \"const\" WS1 ident WS? \":\" WS? type_expr\n                | \"comptime\" WS1 ident WS? \":\" WS? type_expr\n                ;",
      "tests": []
    },
    {
      "name": "where_clause",
      "body": "\"where\" WS1 where_bounds ;",
      "tests": []
    },
    {
      "name": "where_bounds",
      "body": "where_bound { WS? \",\" WS? where_bound } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "where_bound",
      "body": "type_expr WS? \":\" WS? trait_bound\n              | type_expr WS? \"==\" WS? type_expr\n              | expr WS? rel_op WS? expr\n              ;",
      "tests": []
    },
    {
      "name": "trait_bound",
      "body": "type_expr { WS? \"+\" WS? type_expr } ;",
      "tests": []
    },
    {
      "name": "param_list",
      "body": "param { WS? \",\" WS? param } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "param",
      "body": "self_param | normal_param | variadic_param ;",
      "tests": []
    },
    {
      "name": "self_param",
      "body": "[ \"&\" WS? ] [ \"mut\" WS1 ] \"self\" ;",
      "tests": []
    },
    {
      "name": "normal_param",
      "body": "[ param_mode WS1 ] pattern [ WS? \":\" WS? type_expr ] [ WS? \"=\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "variadic_param",
      "body": "\"...\" | ident WS? \":\" WS? \"...\" type_expr ;",
      "tests": []
    },
    {
      "name": "param_mode",
      "body": "\"mut\" | \"owned\" | \"borrow\" | \"move\" ;",
      "tests": []
    },
    {
      "name": "effects_clause",
      "body": "\"effects\" WS? \"(\" WS? ident_list? WS? \")\" ;",
      "tests": []
    },
    {
      "name": "requires_clause",
      "body": "\"requires\" WS? \"(\" WS? capability_list? WS? \")\" ;",
      "tests": []
    },
    {
      "name": "capability_list",
      "body": "capability { WS? \",\" WS? capability } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "capability",
      "body": "ident { \".\" ident } ;",
      "tests": []
    },
    {
      "name": "module_path",
      "body": "relative? package_parts ;",
      "tests": []
    },
    {
      "name": "package_path",
      "body": "relative? package_parts ;",
      "tests": []
    },
    {
      "name": "relative",
      "body": "{ \".\" } ;",
      "tests": []
    },
    {
      "name": "package_parts",
      "body": "ident { ( \"/\" | \".\" | \"::\" ) ident } ;",
      "tests": []
    },
    {
      "name": "ident_list",
      "body": "ident { WS? \",\" WS? ident } [ WS? \",\" ] ;\n\n<<< ================= Compiler Declarations ================= >>>",
      "tests": []
    },
    {
      "name": "compiler_decl",
      "body": "{ attr_prefix WS? } \"compiler\" WS1 ident WS? \"{\" WS? compiler_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "compiler_items",
      "body": "compiler_item { WS? compiler_item } ;",
      "tests": []
    },
    {
      "name": "compiler_item",
      "body": "compiler_phase_decl\n                | compiler_stage_decl\n                | compiler_artifact_decl\n                | compiler_pipeline_decl\n                | compiler_cache_decl\n                | compiler_target_decl\n                ;",
      "tests": []
    },
    {
      "name": "compiler_phase_decl",
      "body": "\"phase\" WS1 ident WS? \"{\" WS?\n                        \"input\" WS? \":\" WS? type_expr WS? \";\"\n                        \"output\" WS? \":\" WS? type_expr WS? \";\"\n                        [ \"errors\" WS? \":\" WS? type_expr WS? \";\" ]\n                        WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "compiler_stage_decl",
      "body": "\"stage\" WS1 ident WS? \":\" WS? ident_list WS? \";\" ;",
      "tests": []
    },
    {
      "name": "compiler_artifact_decl",
      "body": "\"artifact\" WS1 ident WS? \":\" WS? type_expr WS? \";\" ;",
      "tests": []
    },
    {
      "name": "compiler_pipeline_decl",
      "body": "\"pipeline\" WS1 ident WS? \"{\" WS? pipeline_step* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "pipeline_step",
      "body": "\"run\" WS1 ident [ WS? \"as\" WS? ident ] WS? \";\"\n                | \"dump\" WS1 ident WS? \";\"\n                | \"verify\" WS1 ident WS? \";\"\n                ;",
      "tests": []
    },
    {
      "name": "compiler_cache_decl",
      "body": "\"cache\" WS1 ident WS? \"{\" WS? cache_item* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "cache_item",
      "body": "\"key\" WS? \":\" WS? type_expr WS? \";\"\n             | \"value\" WS? \":\" WS? type_expr WS? \";\"\n             | \"strategy\" WS? \":\" WS? ident WS? \";\"\n             ;",
      "tests": []
    },
    {
      "name": "compiler_target_decl",
      "body": "\"target\" WS1 ident WS? \"{\" WS? target_item* WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "target_item",
      "body": "ident WS? \":\" WS? expr WS? \";\" ;",
      "tests": []
    },
    {
      "name": "query_decl",
      "body": "{ attr_prefix WS? } \"query\" WS1 ident\n               \"(\" WS? param_list? WS? \")\"\n               WS? \"->\" WS? type_expr\n               WS? query_body ;",
      "tests": []
    },
    {
      "name": "query_body",
      "body": "block | \";\" ;",
      "tests": []
    },
    {
      "name": "pass_decl",
      "body": "{ attr_prefix WS? } \"pass\" WS1 ident WS? \"{\" WS? pass_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "pass_items",
      "body": "pass_item { WS? pass_item } ;",
      "tests": []
    },
    {
      "name": "pass_item",
      "body": "\"input\" WS? \":\" WS? type_expr WS? \";\"\n            | \"output\" WS? \":\" WS? type_expr WS? \";\"\n            | \"requires\" WS? \":\" WS? ident_list WS? \";\"\n            | \"invalidates\" WS? \":\" WS? ident_list WS? \";\"\n            | proc_decl\n            ;",
      "tests": []
    },
    {
      "name": "backend_decl",
      "body": "{ attr_prefix WS? } \"backend\" WS1 ident WS? \"{\" WS? backend_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "backend_items",
      "body": "backend_item { WS? backend_item } ;",
      "tests": []
    },
    {
      "name": "backend_item",
      "body": "\"target\" WS? \":\" WS? string_lit WS? \";\"\n               | \"format\" WS? \":\" WS? backend_format WS? \";\"\n               | \"emits\" WS? \":\" WS? backend_output WS? \";\"\n               | \"requires\" WS? \":\" WS? ident_list WS? \";\"\n               | proc_decl\n               ;",
      "tests": []
    },
    {
      "name": "backend_format",
      "body": "\"c\" | \"llvm\" | \"asm\" | \"object\" | \"wasm\" | \"ir\" ;",
      "tests": []
    },
    {
      "name": "backend_output",
      "body": "\"source\" | \"assembly\" | \"object\" | \"executable\" | \"library\" ;",
      "tests": []
    },
    {
      "name": "diagnostic_decl",
      "body": "{ attr_prefix WS? } \"diagnostic\" WS1 diagnostic_code WS? \"{\" WS? diagnostic_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "diagnostic_code",
      "body": "ident | string_lit ;",
      "tests": []
    },
    {
      "name": "diagnostic_items",
      "body": "diagnostic_item { WS? diagnostic_item } ;",
      "tests": []
    },
    {
      "name": "diagnostic_item",
      "body": "\"level\" WS? \":\" WS? diagnostic_level WS? \";\"\n                  | \"message\" WS? \":\" WS? string_lit WS? \";\"\n                  | \"label\" WS? \":\" WS? string_lit WS? \";\"\n                  | \"help\" WS? \":\" WS? string_lit WS? \";\"\n                  | \"note\" WS? \":\" WS? string_lit WS? \";\"\n                  | \"suggest\" WS? \":\" WS? string_lit WS? \";\"\n                  ;",
      "tests": []
    },
    {
      "name": "diagnostic_level",
      "body": "\"error\" | \"warning\" | \"note\" | \"help\" | \"fatal\" ;\n\n<<< ================= Attributes ================= >>>",
      "tests": []
    },
    {
      "name": "attr_prefix",
      "body": "outer_attribute | doc_comment | docstring ;",
      "tests": []
    },
    {
      "name": "inner_attribute",
      "body": "\"#![\" attr_path [ \"(\" WS? attr_arg_list? WS? \")\" ] \"]\" ;",
      "tests": []
    },
    {
      "name": "outer_attribute",
      "body": "\"#[\" attr_path [ \"(\" WS? attr_arg_list? WS? \")\" ] \"]\" ;",
      "tests": []
    },
    {
      "name": "doc_comment",
      "body": "\"///\" { ~NEWLINE ANY } ;",
      "tests": []
    },
    {
      "name": "docstring",
      "body": "raw_string_lit ;",
      "tests": []
    },
    {
      "name": "attr_path",
      "body": "ident { \".\" ident } ;",
      "tests": []
    },
    {
      "name": "attr_arg_list",
      "body": "attr_arg { WS? \",\" WS? attr_arg } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "attr_arg",
      "body": "ident\n           | string_lit\n           | int_lit\n           | bool_lit\n           | ident WS? \"=\" WS? literal\n           ;\n\n<<< ================= Blocks / Statements ================= >>>",
      "tests": []
    },
    {
      "name": "block",
      "body": "\"{\" WS? { stmt WS? } \"}\" ;",
      "tests": []
    },
    {
      "name": "stmt",
      "body": "local_const_stmt stmt_end\n       | let_stmt stmt_end\n       | set_stmt stmt_end\n       | give_stmt stmt_end\n       | try_stmt stmt_end\n       | defer_stmt\n       | asm_stmt stmt_end\n       | unsafe_stmt\n       | emit_stmt stmt_end\n       | assert_stmt stmt_end\n       | panic_stmt stmt_end\n       | unreachable_stmt stmt_end\n       | if_stmt\n       | while_stmt\n       | loop_stmt\n       | for_stmt\n       | break_stmt stmt_end\n       | continue_stmt stmt_end\n       | select_stmt\n       | match_stmt\n       | when_match_stmt\n       | with_stmt\n       | critical_stmt\n       | expr_stmt stmt_end\n       ;",
      "tests": []
    },
    {
      "name": "stmt_end",
      "body": "WS? \";\" ;",
      "tests": []
    },
    {
      "name": "local_const_stmt",
      "body": "\"const\" WS1 ident [ WS? \":\" WS? type_expr ] WS? \"=\" WS? expr ;",
      "tests": []
    },
    {
      "name": "let_stmt",
      "body": "\"let\" WS1 [ \"mut\" WS1 ] pattern [ WS? \":\" WS? type_expr ] WS? \"=\" WS? expr ;\n<<< assign_target stays intentionally syntactic here; projection validity and aliasing\n    are enforced later by sema/typeck/borrowck on structured HIR/MIR places. >>>",
      "tests": []
    },
    {
      "name": "set_stmt",
      "body": "\"set\" WS1 assign_target WS? assign_op WS? expr ;",
      "tests": []
    },
    {
      "name": "assign_target",
      "body": "unary_expr ;",
      "tests": []
    },
    {
      "name": "give_stmt",
      "body": "\"give\" [ WS1 expr ] ;",
      "tests": []
    },
    {
      "name": "try_stmt",
      "body": "\"try\" WS1 expr ;",
      "tests": []
    },
    {
      "name": "defer_stmt",
      "body": "\"defer\" WS? block ;",
      "tests": []
    },
    {
      "name": "asm_stmt",
      "body": "\"asm\" WS? \"(\" WS? asm_arg_list? WS? \")\" ;",
      "tests": []
    },
    {
      "name": "asm_arg_list",
      "body": "asm_arg { WS? \",\" WS? asm_arg } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "asm_arg",
      "body": "string_lit | ident WS? \"(\" WS? arg_list? WS? \")\" | ident WS? \":\" WS? expr ;",
      "tests": []
    },
    {
      "name": "unsafe_stmt",
      "body": "\"unsafe\" WS? block ;",
      "tests": []
    },
    {
      "name": "emit_stmt",
      "body": "\"emit\" WS1 expr ;",
      "tests": []
    },
    {
      "name": "assert_stmt",
      "body": "\"assert\" WS1 expr [ WS? \",\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "panic_stmt",
      "body": "\"panic\" WS1 expr ;",
      "tests": []
    },
    {
      "name": "unreachable_stmt",
      "body": "\"unreachable\" ;",
      "tests": []
    },
    {
      "name": "if_stmt",
      "body": "\"if\" WS1 expr WS? block\n            { WS? \"elif\" WS1 expr WS? block }\n            [ WS? \"else\" WS? block ] ;",
      "tests": []
    },
    {
      "name": "while_stmt",
      "body": "\"while\" WS1 expr WS? block ;",
      "tests": []
    },
    {
      "name": "loop_stmt",
      "body": "\"loop\" WS? block ;",
      "tests": []
    },
    {
      "name": "for_stmt",
      "body": "\"for\" WS1 pattern WS1 \"in\" WS1 expr WS? block ;",
      "tests": []
    },
    {
      "name": "break_stmt",
      "body": "\"break\" [ WS1 expr ] ;",
      "tests": []
    },
    {
      "name": "continue_stmt",
      "body": "\"continue\" ;",
      "tests": []
    },
    {
      "name": "select_stmt",
      "body": "\"select\" WS1 expr WS? \"{\" WS?\n                { \"when\" WS1 pattern WS? block WS? }\n                [ \"else\" WS? block ]\n                WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "match_stmt",
      "body": "\"match\" WS1 expr WS?\n               \"{\" WS?\n               { \"case\" WS1 pattern [ WS1 \"if\" WS1 expr ] WS? match_arm_body WS? }\n               [ WS? \"else\" WS? match_arm_body ]\n               WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "match_arm_body",
      "body": "block | \"=>\" WS? expr WS? \";\" ;",
      "tests": []
    },
    {
      "name": "when_match_stmt",
      "body": "\"when\" WS1 expr WS1 \"is\" WS1 pattern WS? block ;",
      "tests": []
    },
    {
      "name": "with_stmt",
      "body": "\"with\" WS1 expr [ WS1 \"as\" WS1 pattern ] WS? block ;",
      "tests": []
    },
    {
      "name": "critical_stmt",
      "body": "\"critical\" WS? block ;",
      "tests": []
    },
    {
      "name": "expr_stmt",
      "body": "expr ;\n\n<<< ================= Expressions ================= >>>",
      "tests": []
    },
    {
      "name": "expr",
      "body": "assign_expr ;",
      "tests": []
    },
    {
      "name": "assign_expr",
      "body": "ternary_expr [ WS? assign_op WS? assign_expr ] ;",
      "tests": []
    },
    {
      "name": "assign_op",
      "body": "\"=\" | \"+=\" | \"-=\" | \"*=\" | \"/=\" | \"%=\" | \"&=\" | \"|=\" | \"^=\" | \"<<=\" | \">>=\" ;",
      "tests": []
    },
    {
      "name": "ternary_expr",
      "body": "coalesce_expr [ WS? \"?\" WS? expr WS? \":\" WS? expr ] ;",
      "tests": []
    },
    {
      "name": "coalesce_expr",
      "body": "range_expr { WS? \"??\" WS? range_expr } ;",
      "tests": []
    },
    {
      "name": "range_expr",
      "body": "or_expr [ WS? ( \"..\" | \"..=\" ) WS? or_expr ] ;",
      "tests": []
    },
    {
      "name": "or_expr",
      "body": "and_expr { WS? ( \"or\" | \"||\" ) WS? and_expr } ;",
      "tests": []
    },
    {
      "name": "and_expr",
      "body": "bit_or_expr { WS? ( \"and\" | \"&&\" ) WS? bit_or_expr } ;",
      "tests": []
    },
    {
      "name": "bit_or_expr",
      "body": "bit_xor_expr { WS? \"|\" WS? bit_xor_expr } ;",
      "tests": []
    },
    {
      "name": "bit_xor_expr",
      "body": "bit_and_expr { WS? \"^\" WS? bit_and_expr } ;",
      "tests": []
    },
    {
      "name": "bit_and_expr",
      "body": "eq_expr { WS? \"&\" WS? eq_expr } ;",
      "tests": []
    },
    {
      "name": "eq_expr",
      "body": "rel_expr { WS? ( \"==\" | \"!=\" ) WS? rel_expr } ;",
      "tests": []
    },
    {
      "name": "rel_expr",
      "body": "shift_expr { WS? rel_op WS? shift_expr } ;",
      "tests": []
    },
    {
      "name": "rel_op",
      "body": "\"<\" | \"<=\" | \">\" | \">=\" | \"in\" | \"not\" WS1 \"in\" ;",
      "tests": []
    },
    {
      "name": "shift_expr",
      "body": "add_expr { WS? ( \"<<\" | \">>\" ) WS? add_expr } ;",
      "tests": []
    },
    {
      "name": "add_expr",
      "body": "mul_expr { WS? ( \"+\" | \"-\" ) WS? mul_expr } ;",
      "tests": []
    },
    {
      "name": "mul_expr",
      "body": "cast_expr { WS? ( \"*\" | \"/\" | \"%\" ) WS? cast_expr } ;",
      "tests": []
    },
    {
      "name": "cast_expr",
      "body": "unary_expr { WS? ( \"as\" WS? type_expr | \"is\" WS? pattern | \"is\" WS1 \"not\" WS1 pattern ) } ;\n\n<<< unary borrow and move syntax are accepted at parse time; whether a use is\n    actually a copy or a move is decided later from inferred types. >>>",
      "tests": []
    },
    {
      "name": "unary_expr",
      "body": "( \"not\" | \"-\" | \"~\" | \"*\" | \"&\" | \"move\" | \"await\" ) WS? unary_expr\n             | postfix_expr\n             ;\n\n<<< postfix chains define the full place surface used later by ownership and\n    borrow analysis: field projection, indexing, call, try and await suffixes. >>>",
      "tests": []
    },
    {
      "name": "postfix_expr",
      "body": "primary { call_suffix | member_suffix | index_suffix | try_suffix | await_suffix } ;",
      "tests": []
    },
    {
      "name": "call_suffix",
      "body": "\"(\" WS? arg_list? WS? \")\" ;",
      "tests": []
    },
    {
      "name": "member_suffix",
      "body": "\".\" ident ;",
      "tests": []
    },
    {
      "name": "index_suffix",
      "body": "\"[\" WS? index_expr WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "try_suffix",
      "body": "\"?\" ;",
      "tests": []
    },
    {
      "name": "await_suffix",
      "body": "\".\" \"await\" ;",
      "tests": []
    },
    {
      "name": "index_expr",
      "body": "expr | slice_expr ;",
      "tests": []
    },
    {
      "name": "slice_expr",
      "body": "[ expr ] \":\" [ expr ] [ \":\" expr ] ;",
      "tests": []
    },
    {
      "name": "primary",
      "body": "literal\n          | builtin_expr\n          | path_expr\n          | struct_lit\n          | list_lit\n          | tuple_lit\n          | set_lit\n          | map_lit\n          | bytes_lit\n          | resource_lit\n          | if_expr\n          | proc_expr\n          | match_expr\n          | lambda_expr\n          | unsafe_expr\n          | block\n          | \"(\" WS? expr WS? \")\"\n          ;",
      "tests": []
    },
    {
      "name": "path_expr",
      "body": "ident { ( \".\" | \"::\" ) ident } ;",
      "tests": []
    },
    {
      "name": "arg_list",
      "body": "arg { WS? \",\" WS? arg } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "arg",
      "body": "ident WS? \":\" WS? expr | expr ;",
      "tests": []
    },
    {
      "name": "tuple_lit",
      "body": "\"(\" WS? expr WS? \",\" WS? expr { WS? \",\" WS? expr } [ WS? \",\" ] WS? \")\" ;",
      "tests": []
    },
    {
      "name": "set_lit",
      "body": "\"set\" WS? \"{\" WS? arg_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "map_lit",
      "body": "\"map\" WS? \"{\" WS? map_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "map_items",
      "body": "map_item { WS? \",\" WS? map_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "map_item",
      "body": "expr WS? \":\" WS? expr ;",
      "tests": []
    },
    {
      "name": "bytes_lit",
      "body": "\"b\" string_lit ;",
      "tests": []
    },
    {
      "name": "resource_lit",
      "body": "\"resource\" WS? \"{\" WS? resource_items? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "resource_items",
      "body": "resource_item { WS? \",\" WS? resource_item } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "resource_item",
      "body": "ident WS? \":\" WS? expr ;",
      "tests": []
    },
    {
      "name": "struct_lit",
      "body": "type_path WS? \"{\" WS? field_init_list? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "type_path",
      "body": "ident { ( \".\" | \"::\" ) ident } ;",
      "tests": []
    },
    {
      "name": "field_init_list",
      "body": "field_init { WS? \",\" WS? field_init } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "field_init",
      "body": "ident WS? \":\" WS? expr\n             | ident\n             | \"..\" expr\n             ;",
      "tests": []
    },
    {
      "name": "if_expr",
      "body": "\"if\" WS1 expr WS? block\n            { WS? \"elif\" WS1 expr WS? block }\n            [ WS? \"else\" WS? block ] ;",
      "tests": []
    },
    {
      "name": "proc_expr",
      "body": "{ attr_prefix WS? } proc_modifier* \"proc\" WS? \"(\" WS? param_list? WS? \")\"\n              [ WS? \"->\" WS? type_expr ]\n              WS? proc_suffix*\n              WS? block ;",
      "tests": []
    },
    {
      "name": "match_expr",
      "body": "\"match\" WS1 expr WS?\n               \"{\" WS?\n               { \"case\" WS1 pattern [ WS1 \"if\" WS1 expr ] WS? match_arm_body WS? }\n               [ WS? \"else\" WS? match_arm_body ]\n               WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "lambda_expr",
      "body": "\"|\" WS? param_list? WS? \"|\" WS? ( expr | block ) ;",
      "tests": []
    },
    {
      "name": "unsafe_expr",
      "body": "\"unsafe\" WS? block ;",
      "tests": []
    },
    {
      "name": "builtin_expr",
      "body": "sizeof_expr | alignof_expr | offsetof_expr | typeof_expr | nameof_expr ;",
      "tests": []
    },
    {
      "name": "sizeof_expr",
      "body": "\"sizeof\" WS? \"(\" WS? ( type_expr | expr ) WS? \")\" ;",
      "tests": []
    },
    {
      "name": "alignof_expr",
      "body": "\"alignof\" WS? \"(\" WS? type_expr WS? \")\" ;",
      "tests": []
    },
    {
      "name": "offsetof_expr",
      "body": "\"offsetof\" WS? \"(\" WS? type_expr WS? \",\" WS? ident WS? \")\" ;",
      "tests": []
    },
    {
      "name": "typeof_expr",
      "body": "\"typeof\" WS? \"(\" WS? expr WS? \")\" ;",
      "tests": []
    },
    {
      "name": "nameof_expr",
      "body": "\"nameof\" WS? \"(\" WS? path_expr WS? \")\" ;\n\n<<< ================= Patterns ================= >>>",
      "tests": []
    },
    {
      "name": "pattern",
      "body": "pattern_or ;",
      "tests": []
    },
    {
      "name": "pattern_or",
      "body": "pattern_atom { WS? \"|\" WS? pattern_atom } ;",
      "tests": []
    },
    {
      "name": "pattern_atom",
      "body": "\"_\"\n               | literal\n               | \"mut\" WS1 pattern_bind\n               | \"ref\" WS1 pattern_bind\n               | pattern_bind\n               | pattern_ctor\n               | pattern_struct\n               | pattern_tuple\n               | pattern_list\n               | pattern_range\n               ;",
      "tests": []
    },
    {
      "name": "pattern_bind",
      "body": "ident ;",
      "tests": []
    },
    {
      "name": "pattern_ctor",
      "body": "pattern_head [ \"(\" WS? pattern_args? WS? \")\" ] ;",
      "tests": []
    },
    {
      "name": "pattern_head",
      "body": "ident { ( \".\" | \"::\" ) ident } ;",
      "tests": []
    },
    {
      "name": "pattern_args",
      "body": "pattern { WS? \",\" WS? pattern } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "pattern_struct",
      "body": "pattern_head WS? \"{\" WS? pattern_fields? WS? \"}\" ;",
      "tests": []
    },
    {
      "name": "pattern_fields",
      "body": "pattern_field { WS? \",\" WS? pattern_field } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "pattern_field",
      "body": "ident [ WS? \":\" WS? pattern ] | \"..\" ;",
      "tests": []
    },
    {
      "name": "pattern_tuple",
      "body": "\"(\" WS? pattern WS? \",\" WS? pattern { WS? \",\" WS? pattern } [ WS? \",\" ] WS? \")\" ;",
      "tests": []
    },
    {
      "name": "pattern_list",
      "body": "\"[\" WS? pattern_args? WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "pattern_range",
      "body": "literal WS? ( \"..\" | \"..=\" ) WS? literal ;\n\n<<< ================= Types ================= >>>",
      "tests": []
    },
    {
      "name": "type_expr",
      "body": "type_union ;",
      "tests": []
    },
    {
      "name": "type_union",
      "body": "type_prefix { WS? \"|\" WS? type_prefix } ;",
      "tests": []
    },
    {
      "name": "type_prefix",
      "body": "type_qualifier* type_atom ;",
      "tests": []
    },
    {
      "name": "type_qualifier",
      "body": "type_qual WS1 | addr_space WS1 ;",
      "tests": []
    },
    {
      "name": "type_qual",
      "body": "\"const\" | \"volatile\" | \"atomic\" | \"mut\" | \"owned\" | \"borrow\" ;",
      "tests": []
    },
    {
      "name": "addr_space",
      "body": "\"user\" | \"kernel\" | \"phys\" | \"mmio\" | \"dma\" ;",
      "tests": []
    },
    {
      "name": "type_atom",
      "body": "reference_type\n            | pointer_type\n            | optional_type\n            | fixed_array_type\n            | slice_type\n            | tuple_type\n            | proc_type\n            | dyn_type\n            | impl_trait_type\n            | type_primary\n            ;\n\n<<< shared and mutable references are part of the core surface grammar; lifetime,\n    aliasing and region closure remain semantic checks outside the parser. >>>",
      "tests": []
    },
    {
      "name": "reference_type",
      "body": "\"&\" WS? [ lifetime WS? ] [ \"mut\" WS1 ] type_expr ;",
      "tests": []
    },
    {
      "name": "pointer_type",
      "body": "\"*\" WS? [ \"const\" WS1 | \"mut\" WS1 | \"volatile\" WS1 | addr_space WS1 ] type_expr ;",
      "tests": []
    },
    {
      "name": "optional_type",
      "body": "\"?\" WS? type_expr ;",
      "tests": []
    },
    {
      "name": "fixed_array_type",
      "body": "\"[\" WS? type_expr WS? \";\" WS? expr WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "slice_type",
      "body": "\"[\" WS? type_expr WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "tuple_type",
      "body": "\"(\" WS? type_expr WS? \",\" WS? type_expr { WS? \",\" WS? type_expr } [ WS? \",\" ] WS? \")\" ;",
      "tests": []
    },
    {
      "name": "proc_type",
      "body": "\"proc\" WS? \"(\" WS? type_list? WS? \")\" [ WS? \"->\" WS? type_expr ] ;",
      "tests": []
    },
    {
      "name": "type_list",
      "body": "type_param { WS? \",\" WS? type_param } [ WS? \",\" ] ;",
      "tests": []
    },
    {
      "name": "type_param",
      "body": "ident WS? \":\" WS? type_expr | type_expr ;",
      "tests": []
    },
    {
      "name": "dyn_type",
      "body": "\"dyn\" WS1 trait_bound ;",
      "tests": []
    },
    {
      "name": "impl_trait_type",
      "body": "\"impl\" WS1 trait_bound ;",
      "tests": []
    },
    {
      "name": "type_primary",
      "body": "type_path [ \"[\" WS? type_list? WS? \"]\" ]\n               | primitive_type\n               | \"Self\"\n               ;",
      "tests": []
    },
    {
      "name": "lifetime",
      "body": "\"'\" ident ;",
      "tests": []
    },
    {
      "name": "primitive_type",
      "body": "\"void\"\n                 | \"never\"\n                 | \"unit\"\n                 | \"bool\"\n                 | \"char\"\n                 | \"rune\"\n                 | \"str\"\n                 | \"string\"\n                 | \"bytes\"\n                 | \"cstr\"\n                 | \"int\"\n                 | \"i8\" | \"i16\" | \"i32\" | \"i64\" | \"i128\"\n                 | \"u8\" | \"u16\" | \"u32\" | \"u64\" | \"u128\"\n                 | \"usize\" | \"isize\"\n                 | \"intptr\" | \"uintptr\"\n                 | \"f16\" | \"f32\" | \"f64\" | \"f128\"\n                 | \"c_char\" | \"c_int\" | \"c_uint\" | \"c_long\" | \"c_ulong\" | \"c_void\"\n                 | \"TokenId\"\n                 | \"NodeId\"\n                 | \"DefId\"\n                 | \"HirId\"\n                 | \"MirId\"\n                 | \"TypeId\"\n                 | \"SymbolId\"\n                 | \"ScopeId\"\n                 | \"BlockId\"\n                 | \"ValueId\"\n                 | \"InstrId\"\n                 ;\n\n<<< ================= Literals ================= >>>",
      "tests": []
    },
    {
      "name": "literal",
      "body": "bool_lit\n          | null_lit\n          | int_lit\n          | float_lit\n          | char_lit\n          | string_lit\n          | list_lit\n          ;",
      "tests": []
    },
    {
      "name": "list_lit",
      "body": "\"[\" WS? ( list_comp | arg_list? ) WS? \"]\" ;",
      "tests": []
    },
    {
      "name": "list_comp",
      "body": "expr WS1 \"for\" WS1 pattern WS1 \"in\" WS1 expr [ WS1 \"if\" WS1 expr ] ;",
      "tests": []
    },
    {
      "name": "bool_lit",
      "body": "\"true\" | \"false\" ;",
      "tests": []
    },
    {
      "name": "null_lit",
      "body": "\"null\" ;",
      "tests": []
    },
    {
      "name": "int_lit",
      "body": "[ \"-\" ] DIGIT { DIGIT | \"_\" } [ suffix ]\n          | [ \"-\" ] \"0x\" HEXDIGIT { HEXDIGIT | \"_\" } [ suffix ]\n          | [ \"-\" ] \"0b\" BINDIGIT { BINDIGIT | \"_\" } [ suffix ]\n          | [ \"-\" ] \"0o\" OCTDIGIT { OCTDIGIT | \"_\" } [ suffix ]\n          ;",
      "tests": []
    },
    {
      "name": "float_lit",
      "body": "[ \"-\" ] DIGIT { DIGIT | \"_\" } \".\" DIGIT { DIGIT | \"_\" } [ exponent ] [ suffix ] ;",
      "tests": []
    },
    {
      "name": "exponent",
      "body": "( \"e\" | \"E\" ) [ \"+\" | \"-\" ] DIGIT { DIGIT | \"_\" } ;",
      "tests": []
    },
    {
      "name": "char_lit",
      "body": "\"'\" char_char \"'\" ;",
      "tests": []
    },
    {
      "name": "char_char",
      "body": "escape_seq | ~\"'\" ;",
      "tests": []
    },
    {
      "name": "string_lit",
      "body": "\"\\\"\" { string_char } \"\\\"\" | raw_string_lit ;",
      "tests": []
    },
    {
      "name": "string_char",
      "body": "escape_seq | ~\"\\\"\" ;",
      "tests": []
    },
    {
      "name": "escape_seq",
      "body": "\"\\\\n\"\n             | \"\\\\r\"\n             | \"\\\\t\"\n             | \"\\\\0\"\n             | \"\\\\\\\"\"\n             | \"\\\\'\"\n             | \"\\\\\\\\\"\n             | \"\\\\x\" HEXDIGIT HEXDIGIT\n             | \"\\\\u{\" HEXDIGIT { HEXDIGIT } \"}\"\n             ;",
      "tests": []
    },
    {
      "name": "raw_string_lit",
      "body": "\"\\\"\\\"\\\"\" { raw_string_char } \"\\\"\\\"\\\"\"\n                 | \"r\\\"\" { raw_string_char } \"\\\"\"\n                 ;",
      "tests": []
    },
    {
      "name": "raw_string_char",
      "body": "~\"\\\"\\\"\\\"\" ;\n\n<<< ================= Lexical ================= >>>",
      "tests": []
    },
    {
      "name": "line_comment",
      "body": "\"#\" { ~NEWLINE ANY }\n               | \"//\" { ~NEWLINE ANY }\n               ;",
      "tests": []
    },
    {
      "name": "block_comment",
      "body": "\"/*\" { ~\"*/\" ANY } \"*/\" ;",
      "tests": []
    },
    {
      "name": "zone_comment",
      "body": "\"<<<\" { ~\">>>\" ANY } \">>>\" ;",
      "tests": []
    },
    {
      "name": "ident",
      "body": "( LETTER | \"_\" ) { LETTER | DIGIT | \"_\" } ;",
      "tests": []
    },
    {
      "name": "suffix",
      "body": "LETTER { LETTER | DIGIT } ;",
      "tests": []
    },
    {
      "name": "WS",
      "body": "{ \" \" | \"\\t\" | NEWLINE | line_comment | block_comment | zone_comment } ;",
      "tests": []
    },
    {
      "name": "WS1",
      "body": "( \" \" | \"\\t\" | NEWLINE | line_comment | block_comment | zone_comment )\n        { \" \" | \"\\t\" | NEWLINE | line_comment | block_comment | zone_comment } ;",
      "tests": []
    },
    {
      "name": "NEWLINE",
      "body": "\"\\n\" | \"\\r\\n\" ;",
      "tests": []
    },
    {
      "name": "LETTER",
      "body": "\"a\"...\"z\" | \"A\"...\"Z\" ;",
      "tests": []
    },
    {
      "name": "DIGIT",
      "body": "\"0\"...\"9\" ;",
      "tests": []
    },
    {
      "name": "BINDIGIT",
      "body": "\"0\" | \"1\" ;",
      "tests": []
    },
    {
      "name": "OCTDIGIT",
      "body": "\"0\"...\"7\" ;",
      "tests": []
    },
    {
      "name": "HEXDIGIT",
      "body": "DIGIT | \"a\"...\"f\" | \"A\"...\"F\" ;",
      "tests": []
    },
    {
      "name": "EOF",
      "body": "!ANY ;",
      "tests": []
    }
  ]
}