fork/rust
git clone https://git.julia.blue/fork/rust
4560ea788cb
1.39.0
1%{ 2#define YYERROR_VERBOSE 3#define YYSTYPE struct node * 4struct node; 5extern int yylex(); 6extern void yyerror(char const *s); 7extern struct node *mk_node(char const *name, int n, ...); 8extern struct node *mk_atom(char *text); 9extern struct node *mk_none(); 10extern struct node *ext_node(struct node *nd, int n, ...); 11extern void push_back(char c); 12extern char *yytext; 13%} 14%debug 15 16%token SHL 17%token SHR 18%token LE 19%token EQEQ 20%token NE 21%token GE 22%token ANDAND 23%token OROR 24%token SHLEQ 25%token SHREQ 26%token MINUSEQ 27%token ANDEQ 28%token OREQ 29%token PLUSEQ 30%token STAREQ 31%token SLASHEQ 32%token CARETEQ 33%token PERCENTEQ 34%token DOTDOT 35%token DOTDOTDOT 36%token MOD_SEP 37%token RARROW 38%token LARROW 39%token FAT_ARROW 40%token LIT_BYTE 41%token LIT_CHAR 42%token LIT_INTEGER 43%token LIT_FLOAT 44%token LIT_STR 45%token LIT_STR_RAW 46%token LIT_BYTE_STR 47%token LIT_BYTE_STR_RAW 48%token IDENT 49%token UNDERSCORE 50%token LIFETIME 51 52// keywords 53%token SELF 54%token STATIC 55%token ABSTRACT 56%token ALIGNOF 57%token AS 58%token BECOME 59%token BREAK 60%token CATCH 61%token CRATE 62%token DO 63%token ELSE 64%token ENUM 65%token EXTERN 66%token FALSE 67%token FINAL 68%token FN 69%token FOR 70%token IF 71%token IMPL 72%token IN 73%token LET 74%token LOOP 75%token MACRO 76%token MATCH 77%token MOD 78%token MOVE 79%token MUT 80%token OFFSETOF 81%token OVERRIDE 82%token PRIV 83%token PUB 84%token PURE 85%token REF 86%token RETURN 87%token SIZEOF 88%token STRUCT 89%token SUPER 90%token UNION 91%token UNSIZED 92%token TRUE 93%token TRAIT 94%token TYPE 95%token UNSAFE 96%token VIRTUAL 97%token YIELD 98%token DEFAULT 99%token USE 100%token WHILE 101%token CONTINUE 102%token PROC 103%token BOX 104%token CONST 105%token WHERE 106%token TYPEOF 107%token INNER_DOC_COMMENT 108%token OUTER_DOC_COMMENT 109 110%token SHEBANG 111%token SHEBANG_LINE 112%token STATIC_LIFETIME 113 114 /* 115 Quoting from the Bison manual: 116 117 "Finally, the resolution of conflicts works by comparing the precedence 118 of the rule being considered with that of the lookahead token. If the 119 token's precedence is higher, the choice is to shift. If the rule's 120 precedence is higher, the choice is to reduce. If they have equal 121 precedence, the choice is made based on the associativity of that 122 precedence level. The verbose output file made by ā-vā (see Invoking 123 Bison) says how each conflict was resolved" 124 */ 125 126// We expect no shift/reduce or reduce/reduce conflicts in this grammar; 127// all potential ambiguities are scrutinized and eliminated manually. 128%expect 0 129 130// fake-precedence symbol to cause '|' bars in lambda context to parse 131// at low precedence, permit things like |x| foo = bar, where '=' is 132// otherwise lower-precedence than '|'. Also used for proc() to cause 133// things like proc() a + b to parse as proc() { a + b }. 134%precedence LAMBDA 135 136%precedence SELF 137 138// MUT should be lower precedence than IDENT so that in the pat rule, 139// "& MUT pat" has higher precedence than "binding_mode ident [@ pat]" 140%precedence MUT 141 142// IDENT needs to be lower than '{' so that 'foo {' is shifted when 143// trying to decide if we've got a struct-construction expr (esp. in 144// contexts like 'if foo { .') 145// 146// IDENT also needs to be lower precedence than '<' so that '<' in 147// 'foo:bar . <' is shifted (in a trait reference occurring in a 148// bounds list), parsing as foo:(bar<baz>) rather than (foo:bar)<baz>. 149%precedence IDENT 150 // Put the weak keywords that can be used as idents here as well 151%precedence CATCH 152%precedence DEFAULT 153%precedence UNION 154 155// A couple fake-precedence symbols to use in rules associated with + 156// and < in trailing type contexts. These come up when you have a type 157// in the RHS of operator-AS, such as "foo as bar<baz>". The "<" there 158// has to be shifted so the parser keeps trying to parse a type, even 159// though it might well consider reducing the type "bar" and then 160// going on to "<" as a subsequent binop. The "+" case is with 161// trailing type-bounds ("foo as bar:A+B"), for the same reason. 162%precedence SHIFTPLUS 163 164%precedence MOD_SEP 165%precedence RARROW ':' 166 167// In where clauses, "for" should have greater precedence when used as 168// a higher ranked constraint than when used as the beginning of a 169// for_in_type (which is a ty) 170%precedence FORTYPE 171%precedence FOR 172 173// Binops & unops, and their precedences 174%precedence '?' 175%precedence BOX 176%nonassoc DOTDOT 177 178// RETURN needs to be lower-precedence than tokens that start 179// prefix_exprs 180%precedence RETURN YIELD 181 182%right '=' SHLEQ SHREQ MINUSEQ ANDEQ OREQ PLUSEQ STAREQ SLASHEQ CARETEQ PERCENTEQ 183%right LARROW 184%left OROR 185%left ANDAND 186%left EQEQ NE 187%left '<' '>' LE GE 188%left '|' 189%left '^' 190%left '&' 191%left SHL SHR 192%left '+' '-' 193%precedence AS 194%left '*' '/' '%' 195%precedence '!' 196 197%precedence '{' '[' '(' '.' 198 199%precedence RANGE 200 201%start crate 202 203%% 204 205//////////////////////////////////////////////////////////////////////// 206// Part 1: Items and attributes 207//////////////////////////////////////////////////////////////////////// 208 209crate 210: maybe_shebang inner_attrs maybe_mod_items { mk_node("crate", 2, $2, $3); } 211| maybe_shebang maybe_mod_items { mk_node("crate", 1, $2); } 212; 213 214maybe_shebang 215: SHEBANG_LINE 216| %empty 217; 218 219maybe_inner_attrs 220: inner_attrs 221| %empty { $$ = mk_none(); } 222; 223 224inner_attrs 225: inner_attr { $$ = mk_node("InnerAttrs", 1, $1); } 226| inner_attrs inner_attr { $$ = ext_node($1, 1, $2); } 227; 228 229inner_attr 230: SHEBANG '[' meta_item ']' { $$ = mk_node("InnerAttr", 1, $3); } 231| INNER_DOC_COMMENT { $$ = mk_node("InnerAttr", 1, mk_node("doc-comment", 1, mk_atom(yytext))); } 232; 233 234maybe_outer_attrs 235: outer_attrs 236| %empty { $$ = mk_none(); } 237; 238 239outer_attrs 240: outer_attr { $$ = mk_node("OuterAttrs", 1, $1); } 241| outer_attrs outer_attr { $$ = ext_node($1, 1, $2); } 242; 243 244outer_attr 245: '#' '[' meta_item ']' { $$ = $3; } 246| OUTER_DOC_COMMENT { $$ = mk_node("doc-comment", 1, mk_atom(yytext)); } 247; 248 249meta_item 250: ident { $$ = mk_node("MetaWord", 1, $1); } 251| ident '=' lit { $$ = mk_node("MetaNameValue", 2, $1, $3); } 252| ident '(' meta_seq ')' { $$ = mk_node("MetaList", 2, $1, $3); } 253| ident '(' meta_seq ',' ')' { $$ = mk_node("MetaList", 2, $1, $3); } 254; 255 256meta_seq 257: %empty { $$ = mk_none(); } 258| meta_item { $$ = mk_node("MetaItems", 1, $1); } 259| meta_seq ',' meta_item { $$ = ext_node($1, 1, $3); } 260; 261 262maybe_mod_items 263: mod_items 264| %empty { $$ = mk_none(); } 265; 266 267mod_items 268: mod_item { $$ = mk_node("Items", 1, $1); } 269| mod_items mod_item { $$ = ext_node($1, 1, $2); } 270; 271 272attrs_and_vis 273: maybe_outer_attrs visibility { $$ = mk_node("AttrsAndVis", 2, $1, $2); } 274; 275 276mod_item 277: attrs_and_vis item { $$ = mk_node("Item", 2, $1, $2); } 278; 279 280// items that can appear outside of a fn block 281item 282: stmt_item 283| item_macro 284; 285 286// items that can appear in "stmts" 287stmt_item 288: item_static 289| item_const 290| item_type 291| block_item 292| view_item 293; 294 295item_static 296: STATIC ident ':' ty '=' expr ';' { $$ = mk_node("ItemStatic", 3, $2, $4, $6); } 297| STATIC MUT ident ':' ty '=' expr ';' { $$ = mk_node("ItemStatic", 3, $3, $5, $7); } 298; 299 300item_const 301: CONST ident ':' ty '=' expr ';' { $$ = mk_node("ItemConst", 3, $2, $4, $6); } 302; 303 304item_macro 305: path_expr '!' maybe_ident parens_delimited_token_trees ';' { $$ = mk_node("ItemMacro", 3, $1, $3, $4); } 306| path_expr '!' maybe_ident braces_delimited_token_trees { $$ = mk_node("ItemMacro", 3, $1, $3, $4); } 307| path_expr '!' maybe_ident brackets_delimited_token_trees ';'{ $$ = mk_node("ItemMacro", 3, $1, $3, $4); } 308; 309 310view_item 311: use_item 312| extern_fn_item 313| EXTERN CRATE ident ';' { $$ = mk_node("ViewItemExternCrate", 1, $3); } 314| EXTERN CRATE ident AS ident ';' { $$ = mk_node("ViewItemExternCrate", 2, $3, $5); } 315; 316 317extern_fn_item 318: EXTERN maybe_abi item_fn { $$ = mk_node("ViewItemExternFn", 2, $2, $3); } 319; 320 321use_item 322: USE view_path ';' { $$ = mk_node("ViewItemUse", 1, $2); } 323; 324 325view_path 326: path_no_types_allowed { $$ = mk_node("ViewPathSimple", 1, $1); } 327| path_no_types_allowed MOD_SEP '{' '}' { $$ = mk_node("ViewPathList", 2, $1, mk_atom("ViewPathListEmpty")); } 328| MOD_SEP '{' '}' { $$ = mk_node("ViewPathList", 1, mk_atom("ViewPathListEmpty")); } 329| path_no_types_allowed MOD_SEP '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 2, $1, $4); } 330| MOD_SEP '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 1, $3); } 331| path_no_types_allowed MOD_SEP '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 2, $1, $4); } 332| MOD_SEP '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 1, $3); } 333| path_no_types_allowed MOD_SEP '*' { $$ = mk_node("ViewPathGlob", 1, $1); } 334| MOD_SEP '*' { $$ = mk_atom("ViewPathGlob"); } 335| '*' { $$ = mk_atom("ViewPathGlob"); } 336| '{' '}' { $$ = mk_atom("ViewPathListEmpty"); } 337| '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 1, $2); } 338| '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 1, $2); } 339| path_no_types_allowed AS ident { $$ = mk_node("ViewPathSimple", 2, $1, $3); } 340; 341 342block_item 343: item_fn 344| item_unsafe_fn 345| item_mod 346| item_foreign_mod { $$ = mk_node("ItemForeignMod", 1, $1); } 347| item_struct 348| item_enum 349| item_union 350| item_trait 351| item_impl 352; 353 354maybe_ty_ascription 355: ':' ty_sum { $$ = $2; } 356| %empty { $$ = mk_none(); } 357; 358 359maybe_init_expr 360: '=' expr { $$ = $2; } 361| %empty { $$ = mk_none(); } 362; 363 364// structs 365item_struct 366: STRUCT ident generic_params maybe_where_clause struct_decl_args 367{ 368 $$ = mk_node("ItemStruct", 4, $2, $3, $4, $5); 369} 370| STRUCT ident generic_params struct_tuple_args maybe_where_clause ';' 371{ 372 $$ = mk_node("ItemStruct", 4, $2, $3, $4, $5); 373} 374| STRUCT ident generic_params maybe_where_clause ';' 375{ 376 $$ = mk_node("ItemStruct", 3, $2, $3, $4); 377} 378; 379 380struct_decl_args 381: '{' struct_decl_fields '}' { $$ = $2; } 382| '{' struct_decl_fields ',' '}' { $$ = $2; } 383; 384 385struct_tuple_args 386: '(' struct_tuple_fields ')' { $$ = $2; } 387| '(' struct_tuple_fields ',' ')' { $$ = $2; } 388; 389 390struct_decl_fields 391: struct_decl_field { $$ = mk_node("StructFields", 1, $1); } 392| struct_decl_fields ',' struct_decl_field { $$ = ext_node($1, 1, $3); } 393| %empty { $$ = mk_none(); } 394; 395 396struct_decl_field 397: attrs_and_vis ident ':' ty_sum { $$ = mk_node("StructField", 3, $1, $2, $4); } 398; 399 400struct_tuple_fields 401: struct_tuple_field { $$ = mk_node("StructFields", 1, $1); } 402| struct_tuple_fields ',' struct_tuple_field { $$ = ext_node($1, 1, $3); } 403| %empty { $$ = mk_none(); } 404; 405 406struct_tuple_field 407: attrs_and_vis ty_sum { $$ = mk_node("StructField", 2, $1, $2); } 408; 409 410// enums 411item_enum 412: ENUM ident generic_params maybe_where_clause '{' enum_defs '}' { $$ = mk_node("ItemEnum", 0); } 413| ENUM ident generic_params maybe_where_clause '{' enum_defs ',' '}' { $$ = mk_node("ItemEnum", 0); } 414; 415 416enum_defs 417: enum_def { $$ = mk_node("EnumDefs", 1, $1); } 418| enum_defs ',' enum_def { $$ = ext_node($1, 1, $3); } 419| %empty { $$ = mk_none(); } 420; 421 422enum_def 423: attrs_and_vis ident enum_args { $$ = mk_node("EnumDef", 3, $1, $2, $3); } 424; 425 426enum_args 427: '{' struct_decl_fields '}' { $$ = mk_node("EnumArgs", 1, $2); } 428| '{' struct_decl_fields ',' '}' { $$ = mk_node("EnumArgs", 1, $2); } 429| '(' maybe_ty_sums ')' { $$ = mk_node("EnumArgs", 1, $2); } 430| '=' expr { $$ = mk_node("EnumArgs", 1, $2); } 431| %empty { $$ = mk_none(); } 432; 433 434// unions 435item_union 436: UNION ident generic_params maybe_where_clause '{' struct_decl_fields '}' { $$ = mk_node("ItemUnion", 0); } 437| UNION ident generic_params maybe_where_clause '{' struct_decl_fields ',' '}' { $$ = mk_node("ItemUnion", 0); } 438 439item_mod 440: MOD ident ';' { $$ = mk_node("ItemMod", 1, $2); } 441| MOD ident '{' maybe_mod_items '}' { $$ = mk_node("ItemMod", 2, $2, $4); } 442| MOD ident '{' inner_attrs maybe_mod_items '}' { $$ = mk_node("ItemMod", 3, $2, $4, $5); } 443; 444 445item_foreign_mod 446: EXTERN maybe_abi '{' maybe_foreign_items '}' { $$ = mk_node("ItemForeignMod", 1, $4); } 447| EXTERN maybe_abi '{' inner_attrs maybe_foreign_items '}' { $$ = mk_node("ItemForeignMod", 2, $4, $5); } 448; 449 450maybe_abi 451: str 452| %empty { $$ = mk_none(); } 453; 454 455maybe_foreign_items 456: foreign_items 457| %empty { $$ = mk_none(); } 458; 459 460foreign_items 461: foreign_item { $$ = mk_node("ForeignItems", 1, $1); } 462| foreign_items foreign_item { $$ = ext_node($1, 1, $2); } 463; 464 465foreign_item 466: attrs_and_vis STATIC item_foreign_static { $$ = mk_node("ForeignItem", 2, $1, $3); } 467| attrs_and_vis item_foreign_fn { $$ = mk_node("ForeignItem", 2, $1, $2); } 468| attrs_and_vis UNSAFE item_foreign_fn { $$ = mk_node("ForeignItem", 2, $1, $3); } 469; 470 471item_foreign_static 472: maybe_mut ident ':' ty ';' { $$ = mk_node("StaticItem", 3, $1, $2, $4); } 473; 474 475item_foreign_fn 476: FN ident generic_params fn_decl_allow_variadic maybe_where_clause ';' { $$ = mk_node("ForeignFn", 4, $2, $3, $4, $5); } 477; 478 479fn_decl_allow_variadic 480: fn_params_allow_variadic ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); } 481; 482 483fn_params_allow_variadic 484: '(' ')' { $$ = mk_none(); } 485| '(' params ')' { $$ = $2; } 486| '(' params ',' ')' { $$ = $2; } 487| '(' params ',' DOTDOTDOT ')' { $$ = $2; } 488; 489 490visibility 491: PUB { $$ = mk_atom("Public"); } 492| %empty { $$ = mk_atom("Inherited"); } 493; 494 495idents_or_self 496: ident_or_self { $$ = mk_node("IdentsOrSelf", 1, $1); } 497| idents_or_self AS ident { $$ = mk_node("IdentsOrSelf", 2, $1, $3); } 498| idents_or_self ',' ident_or_self { $$ = ext_node($1, 1, $3); } 499; 500 501ident_or_self 502: ident 503| SELF { $$ = mk_atom(yytext); } 504; 505 506item_type 507: TYPE ident generic_params maybe_where_clause '=' ty_sum ';' { $$ = mk_node("ItemTy", 4, $2, $3, $4, $6); } 508; 509 510for_sized 511: FOR '?' ident { $$ = mk_node("ForSized", 1, $3); } 512| FOR ident '?' { $$ = mk_node("ForSized", 1, $2); } 513| %empty { $$ = mk_none(); } 514; 515 516item_trait 517: maybe_unsafe TRAIT ident generic_params for_sized maybe_ty_param_bounds maybe_where_clause '{' maybe_trait_items '}' 518{ 519 $$ = mk_node("ItemTrait", 7, $1, $3, $4, $5, $6, $7, $9); 520} 521; 522 523maybe_trait_items 524: trait_items 525| %empty { $$ = mk_none(); } 526; 527 528trait_items 529: trait_item { $$ = mk_node("TraitItems", 1, $1); } 530| trait_items trait_item { $$ = ext_node($1, 1, $2); } 531; 532 533trait_item 534: trait_const 535| trait_type 536| trait_method 537| maybe_outer_attrs item_macro { $$ = mk_node("TraitMacroItem", 2, $1, $2); } 538; 539 540trait_const 541: maybe_outer_attrs CONST ident maybe_ty_ascription maybe_const_default ';' { $$ = mk_node("ConstTraitItem", 4, $1, $3, $4, $5); } 542; 543 544maybe_const_default 545: '=' expr { $$ = mk_node("ConstDefault", 1, $2); } 546| %empty { $$ = mk_none(); } 547; 548 549trait_type 550: maybe_outer_attrs TYPE ty_param ';' { $$ = mk_node("TypeTraitItem", 2, $1, $3); } 551; 552 553maybe_unsafe 554: UNSAFE { $$ = mk_atom("Unsafe"); } 555| %empty { $$ = mk_none(); } 556; 557 558maybe_default_maybe_unsafe 559: DEFAULT UNSAFE { $$ = mk_atom("DefaultUnsafe"); } 560| DEFAULT { $$ = mk_atom("Default"); } 561| UNSAFE { $$ = mk_atom("Unsafe"); } 562| %empty { $$ = mk_none(); } 563 564trait_method 565: type_method { $$ = mk_node("Required", 1, $1); } 566| method { $$ = mk_node("Provided", 1, $1); } 567; 568 569type_method 570: maybe_outer_attrs maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';' 571{ 572 $$ = mk_node("TypeMethod", 6, $1, $2, $4, $5, $6, $7); 573} 574| maybe_outer_attrs CONST maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';' 575{ 576 $$ = mk_node("TypeMethod", 6, $1, $3, $5, $6, $7, $8); 577} 578| maybe_outer_attrs maybe_unsafe EXTERN maybe_abi FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';' 579{ 580 $$ = mk_node("TypeMethod", 7, $1, $2, $4, $6, $7, $8, $9); 581} 582; 583 584method 585: maybe_outer_attrs maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause inner_attrs_and_block 586{ 587 $$ = mk_node("Method", 7, $1, $2, $4, $5, $6, $7, $8); 588} 589| maybe_outer_attrs CONST maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause inner_attrs_and_block 590{ 591 $$ = mk_node("Method", 7, $1, $3, $5, $6, $7, $8, $9); 592} 593| maybe_outer_attrs maybe_unsafe EXTERN maybe_abi FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause inner_attrs_and_block 594{ 595 $$ = mk_node("Method", 8, $1, $2, $4, $6, $7, $8, $9, $10); 596} 597; 598 599impl_method 600: attrs_and_vis maybe_default maybe_unsafe FN ident generic_params fn_decl_with_self maybe_where_clause inner_attrs_and_block 601{ 602 $$ = mk_node("Method", 8, $1, $2, $3, $5, $6, $7, $8, $9); 603} 604| attrs_and_vis maybe_default CONST maybe_unsafe FN ident generic_params fn_decl_with_self maybe_where_clause inner_attrs_and_block 605{ 606 $$ = mk_node("Method", 8, $1, $2, $4, $6, $7, $8, $9, $10); 607} 608| attrs_and_vis maybe_default maybe_unsafe EXTERN maybe_abi FN ident generic_params fn_decl_with_self maybe_where_clause inner_attrs_and_block 609{ 610 $$ = mk_node("Method", 9, $1, $2, $3, $5, $7, $8, $9, $10, $11); 611} 612; 613 614// There are two forms of impl: 615// 616// impl (<...>)? TY { ... } 617// impl (<...>)? TRAIT for TY { ... } 618// 619// Unfortunately since TY can begin with '<' itself -- as part of a 620// TyQualifiedPath type -- there's an s/r conflict when we see '<' after IMPL: 621// should we reduce one of the early rules of TY (such as maybe_once) 622// or shall we continue shifting into the generic_params list for the 623// impl? 624// 625// The production parser disambiguates a different case here by 626// permitting / requiring the user to provide parens around types when 627// they are ambiguous with traits. We do the same here, regrettably, 628// by splitting ty into ty and ty_prim. 629item_impl 630: maybe_default_maybe_unsafe IMPL generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}' 631{ 632 $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8); 633} 634| maybe_default_maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}' 635{ 636 $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10); 637} 638| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}' 639{ 640 $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10); 641} 642| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}' 643{ 644 $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11); 645} 646| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}' 647{ 648 $$ = mk_node("ItemImplDefault", 3, $1, $3, $4); 649} 650| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}' 651{ 652 $$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4); 653} 654; 655 656maybe_impl_items 657: impl_items 658| %empty { $$ = mk_none(); } 659; 660 661impl_items 662: impl_item { $$ = mk_node("ImplItems", 1, $1); } 663| impl_item impl_items { $$ = ext_node($1, 1, $2); } 664; 665 666impl_item 667: impl_method 668| attrs_and_vis item_macro { $$ = mk_node("ImplMacroItem", 2, $1, $2); } 669| impl_const 670| impl_type 671; 672 673maybe_default 674: DEFAULT { $$ = mk_atom("Default"); } 675| %empty { $$ = mk_none(); } 676; 677 678impl_const 679: attrs_and_vis maybe_default item_const { $$ = mk_node("ImplConst", 3, $1, $2, $3); } 680; 681 682impl_type 683: attrs_and_vis maybe_default TYPE ident generic_params '=' ty_sum ';' { $$ = mk_node("ImplType", 5, $1, $2, $4, $5, $7); } 684; 685 686item_fn 687: FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block 688{ 689 $$ = mk_node("ItemFn", 5, $2, $3, $4, $5, $6); 690} 691| CONST FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block 692{ 693 $$ = mk_node("ItemFn", 5, $3, $4, $5, $6, $7); 694} 695; 696 697item_unsafe_fn 698: UNSAFE FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block 699{ 700 $$ = mk_node("ItemUnsafeFn", 5, $3, $4, $5, $6, $7); 701} 702| CONST UNSAFE FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block 703{ 704 $$ = mk_node("ItemUnsafeFn", 5, $4, $5, $6, $7, $8); 705} 706| UNSAFE EXTERN maybe_abi FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block 707{ 708 $$ = mk_node("ItemUnsafeFn", 6, $3, $5, $6, $7, $8, $9); 709} 710; 711 712fn_decl 713: fn_params ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); } 714; 715 716fn_decl_with_self 717: fn_params_with_self ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); } 718; 719 720fn_decl_with_self_allow_anon_params 721: fn_anon_params_with_self ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); } 722; 723 724fn_params 725: '(' maybe_params ')' { $$ = $2; } 726; 727 728fn_anon_params 729: '(' anon_param anon_params_allow_variadic_tail ')' { $$ = ext_node($2, 1, $3); } 730| '(' ')' { $$ = mk_none(); } 731; 732 733fn_params_with_self 734: '(' maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfLower", 3, $2, $4, $5); } 735| '(' '&' maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfRegion", 3, $3, $5, $6); } 736| '(' '&' lifetime maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfRegion", 4, $3, $4, $6, $7); } 737| '(' maybe_params ')' { $$ = mk_node("SelfStatic", 1, $2); } 738; 739 740fn_anon_params_with_self 741: '(' maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfLower", 3, $2, $4, $5); } 742| '(' '&' maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfRegion", 3, $3, $5, $6); } 743| '(' '&' lifetime maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfRegion", 4, $3, $4, $6, $7); } 744| '(' maybe_anon_params ')' { $$ = mk_node("SelfStatic", 1, $2); } 745; 746 747maybe_params 748: params 749| params ',' 750| %empty { $$ = mk_none(); } 751; 752 753params 754: param { $$ = mk_node("Args", 1, $1); } 755| params ',' param { $$ = ext_node($1, 1, $3); } 756; 757 758param 759: pat ':' ty_sum { $$ = mk_node("Arg", 2, $1, $3); } 760; 761 762inferrable_params 763: inferrable_param { $$ = mk_node("InferrableParams", 1, $1); } 764| inferrable_params ',' inferrable_param { $$ = ext_node($1, 1, $3); } 765; 766 767inferrable_param 768: pat maybe_ty_ascription { $$ = mk_node("InferrableParam", 2, $1, $2); } 769; 770 771maybe_comma_params 772: ',' { $$ = mk_none(); } 773| ',' params { $$ = $2; } 774| ',' params ',' { $$ = $2; } 775| %empty { $$ = mk_none(); } 776; 777 778maybe_comma_anon_params 779: ',' { $$ = mk_none(); } 780| ',' anon_params { $$ = $2; } 781| ',' anon_params ',' { $$ = $2; } 782| %empty { $$ = mk_none(); } 783; 784 785maybe_anon_params 786: anon_params 787| anon_params ',' 788| %empty { $$ = mk_none(); } 789; 790 791anon_params 792: anon_param { $$ = mk_node("Args", 1, $1); } 793| anon_params ',' anon_param { $$ = ext_node($1, 1, $3); } 794; 795 796// anon means it's allowed to be anonymous (type-only), but it can 797// still have a name 798anon_param 799: named_arg ':' ty { $$ = mk_node("Arg", 2, $1, $3); } 800| ty 801; 802 803anon_params_allow_variadic_tail 804: ',' DOTDOTDOT { $$ = mk_none(); } 805| ',' anon_param anon_params_allow_variadic_tail { $$ = mk_node("Args", 2, $2, $3); } 806| %empty { $$ = mk_none(); } 807; 808 809named_arg 810: ident 811| UNDERSCORE { $$ = mk_atom("PatWild"); } 812| '&' ident { $$ = $2; } 813| '&' UNDERSCORE { $$ = mk_atom("PatWild"); } 814| ANDAND ident { $$ = $2; } 815| ANDAND UNDERSCORE { $$ = mk_atom("PatWild"); } 816| MUT ident { $$ = $2; } 817; 818 819ret_ty 820: RARROW '!' { $$ = mk_none(); } 821| RARROW ty { $$ = mk_node("ret-ty", 1, $2); } 822| %prec IDENT %empty { $$ = mk_none(); } 823; 824 825generic_params 826: '<' '>' { $$ = mk_node("Generics", 2, mk_none(), mk_none()); } 827| '<' lifetimes '>' { $$ = mk_node("Generics", 2, $2, mk_none()); } 828| '<' lifetimes ',' '>' { $$ = mk_node("Generics", 2, $2, mk_none()); } 829| '<' lifetimes SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, mk_none()); } 830| '<' lifetimes ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, mk_none()); } 831| '<' lifetimes ',' ty_params '>' { $$ = mk_node("Generics", 2, $2, $4); } 832| '<' lifetimes ',' ty_params ',' '>' { $$ = mk_node("Generics", 2, $2, $4); } 833| '<' lifetimes ',' ty_params SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, $4); } 834| '<' lifetimes ',' ty_params ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, $4); } 835| '<' ty_params '>' { $$ = mk_node("Generics", 2, mk_none(), $2); } 836| '<' ty_params ',' '>' { $$ = mk_node("Generics", 2, mk_none(), $2); } 837| '<' ty_params SHR { push_back('>'); $$ = mk_node("Generics", 2, mk_none(), $2); } 838| '<' ty_params ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, mk_none(), $2); } 839| %empty { $$ = mk_none(); } 840; 841 842maybe_where_clause 843: %empty { $$ = mk_none(); } 844| where_clause 845; 846 847where_clause 848: WHERE where_predicates { $$ = mk_node("WhereClause", 1, $2); } 849| WHERE where_predicates ',' { $$ = mk_node("WhereClause", 1, $2); } 850; 851 852where_predicates 853: where_predicate { $$ = mk_node("WherePredicates", 1, $1); } 854| where_predicates ',' where_predicate { $$ = ext_node($1, 1, $3); } 855; 856 857where_predicate 858: maybe_for_lifetimes lifetime ':' bounds { $$ = mk_node("WherePredicate", 3, $1, $2, $4); } 859| maybe_for_lifetimes ty ':' ty_param_bounds { $$ = mk_node("WherePredicate", 3, $1, $2, $4); } 860; 861 862maybe_for_lifetimes 863: FOR '<' lifetimes '>' { $$ = mk_none(); } 864| %prec FORTYPE %empty { $$ = mk_none(); } 865 866ty_params 867: ty_param { $$ = mk_node("TyParams", 1, $1); } 868| ty_params ',' ty_param { $$ = ext_node($1, 1, $3); } 869; 870 871// A path with no type parameters; e.g. `foo::bar::Baz` 872// 873// These show up in 'use' view-items, because these are processed 874// without respect to types. 875path_no_types_allowed 876: ident { $$ = mk_node("ViewPath", 1, $1); } 877| MOD_SEP ident { $$ = mk_node("ViewPath", 1, $2); } 878| SELF { $$ = mk_node("ViewPath", 1, mk_atom("Self")); } 879| MOD_SEP SELF { $$ = mk_node("ViewPath", 1, mk_atom("Self")); } 880| SUPER { $$ = mk_node("ViewPath", 1, mk_atom("Super")); } 881| MOD_SEP SUPER { $$ = mk_node("ViewPath", 1, mk_atom("Super")); } 882| path_no_types_allowed MOD_SEP ident { $$ = ext_node($1, 1, $3); } 883; 884 885// A path with a lifetime and type parameters, with no double colons 886// before the type parameters; e.g. `foo::bar<'a>::Baz<T>` 887// 888// These show up in "trait references", the components of 889// type-parameter bounds lists, as well as in the prefix of the 890// path_generic_args_and_bounds rule, which is the full form of a 891// named typed expression. 892// 893// They do not have (nor need) an extra '::' before '<' because 894// unlike in expr context, there are no "less-than" type exprs to 895// be ambiguous with. 896path_generic_args_without_colons 897: %prec IDENT 898 ident { $$ = mk_node("components", 1, $1); } 899| %prec IDENT 900 ident generic_args { $$ = mk_node("components", 2, $1, $2); } 901| %prec IDENT 902 ident '(' maybe_ty_sums ')' ret_ty { $$ = mk_node("components", 2, $1, $3); } 903| %prec IDENT 904 path_generic_args_without_colons MOD_SEP ident { $$ = ext_node($1, 1, $3); } 905| %prec IDENT 906 path_generic_args_without_colons MOD_SEP ident generic_args { $$ = ext_node($1, 2, $3, $4); } 907| %prec IDENT 908 path_generic_args_without_colons MOD_SEP ident '(' maybe_ty_sums ')' ret_ty { $$ = ext_node($1, 2, $3, $5); } 909; 910 911generic_args 912: '<' generic_values '>' { $$ = $2; } 913| '<' generic_values SHR { push_back('>'); $$ = $2; } 914| '<' generic_values GE { push_back('='); $$ = $2; } 915| '<' generic_values SHREQ { push_back('>'); push_back('='); $$ = $2; } 916// If generic_args starts with "<<", the first arg must be a 917// TyQualifiedPath because that's the only type that can start with a 918// '<'. This rule parses that as the first ty_sum and then continues 919// with the rest of generic_values. 920| SHL ty_qualified_path_and_generic_values '>' { $$ = $2; } 921| SHL ty_qualified_path_and_generic_values SHR { push_back('>'); $$ = $2; } 922| SHL ty_qualified_path_and_generic_values GE { push_back('='); $$ = $2; } 923| SHL ty_qualified_path_and_generic_values SHREQ { push_back('>'); push_back('='); $$ = $2; } 924; 925 926generic_values 927: maybe_ty_sums_and_or_bindings { $$ = mk_node("GenericValues", 1, $1); } 928; 929 930maybe_ty_sums_and_or_bindings 931: ty_sums 932| ty_sums ',' 933| ty_sums ',' bindings { $$ = mk_node("TySumsAndBindings", 2, $1, $3); } 934| bindings 935| bindings ',' 936| %empty { $$ = mk_none(); } 937; 938 939maybe_bindings 940: ',' bindings { $$ = $2; } 941| %empty { $$ = mk_none(); } 942; 943 944//////////////////////////////////////////////////////////////////////// 945// Part 2: Patterns 946//////////////////////////////////////////////////////////////////////// 947 948pat 949: UNDERSCORE { $$ = mk_atom("PatWild"); } 950| '&' pat { $$ = mk_node("PatRegion", 1, $2); } 951| '&' MUT pat { $$ = mk_node("PatRegion", 1, $3); } 952| ANDAND pat { $$ = mk_node("PatRegion", 1, mk_node("PatRegion", 1, $2)); } 953| '(' ')' { $$ = mk_atom("PatUnit"); } 954| '(' pat_tup ')' { $$ = mk_node("PatTup", 1, $2); } 955| '[' pat_vec ']' { $$ = mk_node("PatVec", 1, $2); } 956| lit_or_path 957| lit_or_path DOTDOTDOT lit_or_path { $$ = mk_node("PatRange", 2, $1, $3); } 958| path_expr '{' pat_struct '}' { $$ = mk_node("PatStruct", 2, $1, $3); } 959| path_expr '(' ')' { $$ = mk_node("PatEnum", 2, $1, mk_none()); } 960| path_expr '(' pat_tup ')' { $$ = mk_node("PatEnum", 2, $1, $3); } 961| path_expr '!' maybe_ident delimited_token_trees { $$ = mk_node("PatMac", 3, $1, $3, $4); } 962| binding_mode ident { $$ = mk_node("PatIdent", 2, $1, $2); } 963| ident '@' pat { $$ = mk_node("PatIdent", 3, mk_node("BindByValue", 1, mk_atom("MutImmutable")), $1, $3); } 964| binding_mode ident '@' pat { $$ = mk_node("PatIdent", 3, $1, $2, $4); } 965| BOX pat { $$ = mk_node("PatUniq", 1, $2); } 966| '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident { $$ = mk_node("PatQualifiedPath", 3, $2, $3, $6); } 967| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident 968{ 969 $$ = mk_node("PatQualifiedPath", 3, mk_node("PatQualifiedPath", 3, $2, $3, $6), $7, $10); 970} 971; 972 973pats_or 974: pat { $$ = mk_node("Pats", 1, $1); } 975| pats_or '|' pat { $$ = ext_node($1, 1, $3); } 976; 977 978binding_mode 979: REF { $$ = mk_node("BindByRef", 1, mk_atom("MutImmutable")); } 980| REF MUT { $$ = mk_node("BindByRef", 1, mk_atom("MutMutable")); } 981| MUT { $$ = mk_node("BindByValue", 1, mk_atom("MutMutable")); } 982; 983 984lit_or_path 985: path_expr { $$ = mk_node("PatLit", 1, $1); } 986| lit { $$ = mk_node("PatLit", 1, $1); } 987| '-' lit { $$ = mk_node("PatLit", 1, $2); } 988; 989 990pat_field 991: ident { $$ = mk_node("PatField", 1, $1); } 992| binding_mode ident { $$ = mk_node("PatField", 2, $1, $2); } 993| BOX ident { $$ = mk_node("PatField", 2, mk_atom("box"), $2); } 994| BOX binding_mode ident { $$ = mk_node("PatField", 3, mk_atom("box"), $2, $3); } 995| ident ':' pat { $$ = mk_node("PatField", 2, $1, $3); } 996| binding_mode ident ':' pat { $$ = mk_node("PatField", 3, $1, $2, $4); } 997| LIT_INTEGER ':' pat { $$ = mk_node("PatField", 2, mk_atom(yytext), $3); } 998; 999 1000pat_fields 1001: pat_field { $$ = mk_node("PatFields", 1, $1); } 1002| pat_fields ',' pat_field { $$ = ext_node($1, 1, $3); } 1003; 1004 1005pat_struct 1006: pat_fields { $$ = mk_node("PatStruct", 2, $1, mk_atom("false")); } 1007| pat_fields ',' { $$ = mk_node("PatStruct", 2, $1, mk_atom("false")); } 1008| pat_fields ',' DOTDOT { $$ = mk_node("PatStruct", 2, $1, mk_atom("true")); } 1009| DOTDOT { $$ = mk_node("PatStruct", 1, mk_atom("true")); } 1010| %empty { $$ = mk_node("PatStruct", 1, mk_none()); } 1011; 1012 1013pat_tup 1014: pat_tup_elts { $$ = mk_node("PatTup", 2, $1, mk_none()); } 1015| pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, mk_none()); } 1016| pat_tup_elts DOTDOT { $$ = mk_node("PatTup", 2, $1, mk_none()); } 1017| pat_tup_elts ',' DOTDOT { $$ = mk_node("PatTup", 2, $1, mk_none()); } 1018| pat_tup_elts DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, $1, $4); } 1019| pat_tup_elts DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, $4); } 1020| pat_tup_elts ',' DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, $1, $5); } 1021| pat_tup_elts ',' DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, $5); } 1022| DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, mk_none(), $3); } 1023| DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, mk_none(), $3); } 1024| DOTDOT { $$ = mk_node("PatTup", 2, mk_none(), mk_none()); } 1025; 1026 1027pat_tup_elts 1028: pat { $$ = mk_node("PatTupElts", 1, $1); } 1029| pat_tup_elts ',' pat { $$ = ext_node($1, 1, $3); } 1030; 1031 1032pat_vec 1033: pat_vec_elts { $$ = mk_node("PatVec", 2, $1, mk_none()); } 1034| pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, mk_none()); } 1035| pat_vec_elts DOTDOT { $$ = mk_node("PatVec", 2, $1, mk_none()); } 1036| pat_vec_elts ',' DOTDOT { $$ = mk_node("PatVec", 2, $1, mk_none()); } 1037| pat_vec_elts DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, $1, $4); } 1038| pat_vec_elts DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, $4); } 1039| pat_vec_elts ',' DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, $1, $5); } 1040| pat_vec_elts ',' DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, $5); } 1041| DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, mk_none(), $3); } 1042| DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, mk_none(), $3); } 1043| DOTDOT { $$ = mk_node("PatVec", 2, mk_none(), mk_none()); } 1044| %empty { $$ = mk_node("PatVec", 2, mk_none(), mk_none()); } 1045; 1046 1047pat_vec_elts 1048: pat { $$ = mk_node("PatVecElts", 1, $1); } 1049| pat_vec_elts ',' pat { $$ = ext_node($1, 1, $3); } 1050; 1051 1052//////////////////////////////////////////////////////////////////////// 1053// Part 3: Types 1054//////////////////////////////////////////////////////////////////////// 1055 1056ty 1057: ty_prim 1058| ty_closure 1059| '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident { $$ = mk_node("TyQualifiedPath", 3, $2, $3, $6); } 1060| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident { $$ = mk_node("TyQualifiedPath", 3, mk_node("TyQualifiedPath", 3, $2, $3, $6), $7, $10); } 1061| '(' ty_sums ')' { $$ = mk_node("TyTup", 1, $2); } 1062| '(' ty_sums ',' ')' { $$ = mk_node("TyTup", 1, $2); } 1063| '(' ')' { $$ = mk_atom("TyNil"); } 1064; 1065 1066ty_prim 1067: %prec IDENT path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("global", 1, mk_atom("false")), $1); } 1068| %prec IDENT MOD_SEP path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("global", 1, mk_atom("true")), $2); } 1069| %prec IDENT SELF MOD_SEP path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("self", 1, mk_atom("true")), $3); } 1070| %prec IDENT path_generic_args_without_colons '!' maybe_ident delimited_token_trees { $$ = mk_node("TyMacro", 3, $1, $3, $4); } 1071| %prec IDENT MOD_SEP path_generic_args_without_colons '!' maybe_ident delimited_token_trees { $$ = mk_node("TyMacro", 3, $2, $4, $5); } 1072| BOX ty { $$ = mk_node("TyBox", 1, $2); } 1073| '*' maybe_mut_or_const ty { $$ = mk_node("TyPtr", 2, $2, $3); } 1074| '&' ty { $$ = mk_node("TyRptr", 2, mk_atom("MutImmutable"), $2); } 1075| '&' MUT ty { $$ = mk_node("TyRptr", 2, mk_atom("MutMutable"), $3); } 1076| ANDAND ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 2, mk_atom("MutImmutable"), $2)); } 1077| ANDAND MUT ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 2, mk_atom("MutMutable"), $3)); } 1078| '&' lifetime maybe_mut ty { $$ = mk_node("TyRptr", 3, $2, $3, $4); } 1079| ANDAND lifetime maybe_mut ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 3, $2, $3, $4)); } 1080| '[' ty ']' { $$ = mk_node("TyVec", 1, $2); } 1081| '[' ty ',' DOTDOT expr ']' { $$ = mk_node("TyFixedLengthVec", 2, $2, $5); } 1082| '[' ty ';' expr ']' { $$ = mk_node("TyFixedLengthVec", 2, $2, $4); } 1083| TYPEOF '(' expr ')' { $$ = mk_node("TyTypeof", 1, $3); } 1084| UNDERSCORE { $$ = mk_atom("TyInfer"); } 1085| ty_bare_fn 1086| for_in_type 1087; 1088 1089ty_bare_fn 1090: FN ty_fn_decl { $$ = $2; } 1091| UNSAFE FN ty_fn_decl { $$ = $3; } 1092| EXTERN maybe_abi FN ty_fn_decl { $$ = $4; } 1093| UNSAFE EXTERN maybe_abi FN ty_fn_decl { $$ = $5; } 1094; 1095 1096ty_fn_decl 1097: generic_params fn_anon_params ret_ty { $$ = mk_node("TyFnDecl", 3, $1, $2, $3); } 1098; 1099 1100ty_closure 1101: UNSAFE '|' anon_params '|' maybe_bounds ret_ty { $$ = mk_node("TyClosure", 3, $3, $5, $6); } 1102| '|' anon_params '|' maybe_bounds ret_ty { $$ = mk_node("TyClosure", 3, $2, $4, $5); } 1103| UNSAFE OROR maybe_bounds ret_ty { $$ = mk_node("TyClosure", 2, $3, $4); } 1104| OROR maybe_bounds ret_ty { $$ = mk_node("TyClosure", 2, $2, $3); } 1105; 1106 1107for_in_type 1108: FOR '<' maybe_lifetimes '>' for_in_type_suffix { $$ = mk_node("ForInType", 2, $3, $5); } 1109; 1110 1111for_in_type_suffix 1112: ty_bare_fn 1113| trait_ref 1114| ty_closure 1115; 1116 1117maybe_mut 1118: MUT { $$ = mk_atom("MutMutable"); } 1119| %prec MUT %empty { $$ = mk_atom("MutImmutable"); } 1120; 1121 1122maybe_mut_or_const 1123: MUT { $$ = mk_atom("MutMutable"); } 1124| CONST { $$ = mk_atom("MutImmutable"); } 1125| %empty { $$ = mk_atom("MutImmutable"); } 1126; 1127 1128ty_qualified_path_and_generic_values 1129: ty_qualified_path maybe_bindings 1130{ 1131 $$ = mk_node("GenericValues", 3, mk_none(), mk_node("TySums", 1, mk_node("TySum", 1, $1)), $2); 1132} 1133| ty_qualified_path ',' ty_sums maybe_bindings 1134{ 1135 $$ = mk_node("GenericValues", 3, mk_none(), mk_node("TySums", 2, $1, $3), $4); 1136} 1137; 1138 1139ty_qualified_path 1140: ty_sum AS trait_ref '>' MOD_SEP ident { $$ = mk_node("TyQualifiedPath", 3, $1, $3, $6); } 1141| ty_sum AS trait_ref '>' MOD_SEP ident '+' ty_param_bounds { $$ = mk_node("TyQualifiedPath", 3, $1, $3, $6); } 1142; 1143 1144maybe_ty_sums 1145: ty_sums 1146| ty_sums ',' 1147| %empty { $$ = mk_none(); } 1148; 1149 1150ty_sums 1151: ty_sum { $$ = mk_node("TySums", 1, $1); } 1152| ty_sums ',' ty_sum { $$ = ext_node($1, 1, $3); } 1153; 1154 1155ty_sum 1156: ty_sum_elt { $$ = mk_node("TySum", 1, $1); } 1157| ty_sum '+' ty_sum_elt { $$ = ext_node($1, 1, $3); } 1158; 1159 1160ty_sum_elt 1161: ty 1162| lifetime 1163; 1164 1165ty_prim_sum 1166: ty_prim_sum_elt { $$ = mk_node("TySum", 1, $1); } 1167| ty_prim_sum '+' ty_prim_sum_elt { $$ = ext_node($1, 1, $3); } 1168; 1169 1170ty_prim_sum_elt 1171: ty_prim 1172| lifetime 1173; 1174 1175maybe_ty_param_bounds 1176: ':' ty_param_bounds { $$ = $2; } 1177| %empty { $$ = mk_none(); } 1178; 1179 1180ty_param_bounds 1181: boundseq 1182| %empty { $$ = mk_none(); } 1183; 1184 1185boundseq 1186: polybound 1187| boundseq '+' polybound { $$ = ext_node($1, 1, $3); } 1188; 1189 1190polybound 1191: FOR '<' maybe_lifetimes '>' bound { $$ = mk_node("PolyBound", 2, $3, $5); } 1192| bound 1193| '?' FOR '<' maybe_lifetimes '>' bound { $$ = mk_node("PolyBound", 2, $4, $6); } 1194| '?' bound { $$ = $2; } 1195; 1196 1197bindings 1198: binding { $$ = mk_node("Bindings", 1, $1); } 1199| bindings ',' binding { $$ = ext_node($1, 1, $3); } 1200; 1201 1202binding 1203: ident '=' ty { mk_node("Binding", 2, $1, $3); } 1204; 1205 1206ty_param 1207: ident maybe_ty_param_bounds maybe_ty_default { $$ = mk_node("TyParam", 3, $1, $2, $3); } 1208| ident '?' ident maybe_ty_param_bounds maybe_ty_default { $$ = mk_node("TyParam", 4, $1, $3, $4, $5); } 1209; 1210 1211maybe_bounds 1212: %prec SHIFTPLUS 1213 ':' bounds { $$ = $2; } 1214| %prec SHIFTPLUS %empty { $$ = mk_none(); } 1215; 1216 1217bounds 1218: bound { $$ = mk_node("bounds", 1, $1); } 1219| bounds '+' bound { $$ = ext_node($1, 1, $3); } 1220; 1221 1222bound 1223: lifetime 1224| trait_ref 1225; 1226 1227maybe_ltbounds 1228: %prec SHIFTPLUS 1229 ':' ltbounds { $$ = $2; } 1230| %empty { $$ = mk_none(); } 1231; 1232 1233ltbounds 1234: lifetime { $$ = mk_node("ltbounds", 1, $1); } 1235| ltbounds '+' lifetime { $$ = ext_node($1, 1, $3); } 1236; 1237 1238maybe_ty_default 1239: '=' ty_sum { $$ = mk_node("TyDefault", 1, $2); } 1240| %empty { $$ = mk_none(); } 1241; 1242 1243maybe_lifetimes 1244: lifetimes 1245| lifetimes ',' 1246| %empty { $$ = mk_none(); } 1247; 1248 1249lifetimes 1250: lifetime_and_bounds { $$ = mk_node("Lifetimes", 1, $1); } 1251| lifetimes ',' lifetime_and_bounds { $$ = ext_node($1, 1, $3); } 1252; 1253 1254lifetime_and_bounds 1255: LIFETIME maybe_ltbounds { $$ = mk_node("lifetime", 2, mk_atom(yytext), $2); } 1256| STATIC_LIFETIME { $$ = mk_atom("static_lifetime"); } 1257; 1258 1259lifetime 1260: LIFETIME { $$ = mk_node("lifetime", 1, mk_atom(yytext)); } 1261| STATIC_LIFETIME { $$ = mk_atom("static_lifetime"); } 1262; 1263 1264trait_ref 1265: %prec IDENT path_generic_args_without_colons 1266| %prec IDENT MOD_SEP path_generic_args_without_colons { $$ = $2; } 1267; 1268 1269//////////////////////////////////////////////////////////////////////// 1270// Part 4: Blocks, statements, and expressions 1271//////////////////////////////////////////////////////////////////////// 1272 1273inner_attrs_and_block 1274: '{' maybe_inner_attrs maybe_stmts '}' { $$ = mk_node("ExprBlock", 2, $2, $3); } 1275; 1276 1277block 1278: '{' maybe_stmts '}' { $$ = mk_node("ExprBlock", 1, $2); } 1279; 1280 1281maybe_stmts 1282: stmts 1283| stmts nonblock_expr { $$ = ext_node($1, 1, $2); } 1284| nonblock_expr 1285| %empty { $$ = mk_none(); } 1286; 1287 1288// There are two sub-grammars within a "stmts: exprs" derivation 1289// depending on whether each stmt-expr is a block-expr form; this is to 1290// handle the "semicolon rule" for stmt sequencing that permits 1291// writing 1292// 1293// if foo { bar } 10 1294// 1295// as a sequence of two stmts (one if-expr stmt, one lit-10-expr 1296// stmt). Unfortunately by permitting juxtaposition of exprs in 1297// sequence like that, the non-block expr grammar has to have a 1298// second limited sub-grammar that excludes the prefix exprs that 1299// are ambiguous with binops. That is to say: 1300// 1301// {10} - 1 1302// 1303// should parse as (progn (progn 10) (- 1)) not (- (progn 10) 1), that 1304// is to say, two statements rather than one, at least according to 1305// the mainline rust parser. 1306// 1307// So we wind up with a 3-way split in exprs that occur in stmt lists: 1308// block, nonblock-prefix, and nonblock-nonprefix. 1309// 1310// In non-stmts contexts, expr can relax this trichotomy. 1311 1312stmts 1313: stmt { $$ = mk_node("stmts", 1, $1); } 1314| stmts stmt { $$ = ext_node($1, 1, $2); } 1315; 1316 1317stmt 1318: maybe_outer_attrs let { $$ = $2; } 1319| stmt_item 1320| PUB stmt_item { $$ = $2; } 1321| outer_attrs stmt_item { $$ = $2; } 1322| outer_attrs PUB stmt_item { $$ = $3; } 1323| full_block_expr 1324| maybe_outer_attrs block { $$ = $2; } 1325| nonblock_expr ';' 1326| outer_attrs nonblock_expr ';' { $$ = $2; } 1327| ';' { $$ = mk_none(); } 1328; 1329 1330maybe_exprs 1331: exprs 1332| exprs ',' 1333| %empty { $$ = mk_none(); } 1334; 1335 1336maybe_expr 1337: expr 1338| %empty { $$ = mk_none(); } 1339; 1340 1341exprs 1342: expr { $$ = mk_node("exprs", 1, $1); } 1343| exprs ',' expr { $$ = ext_node($1, 1, $3); } 1344; 1345 1346path_expr 1347: path_generic_args_with_colons 1348| MOD_SEP path_generic_args_with_colons { $$ = $2; } 1349| SELF MOD_SEP path_generic_args_with_colons { $$ = mk_node("SelfPath", 1, $3); } 1350; 1351 1352// A path with a lifetime and type parameters with double colons before 1353// the type parameters; e.g. `foo::bar::<'a>::Baz::<T>` 1354// 1355// These show up in expr context, in order to disambiguate from "less-than" 1356// expressions. 1357path_generic_args_with_colons 1358: ident { $$ = mk_node("components", 1, $1); } 1359| SUPER { $$ = mk_atom("Super"); } 1360| path_generic_args_with_colons MOD_SEP ident { $$ = ext_node($1, 1, $3); } 1361| path_generic_args_with_colons MOD_SEP SUPER { $$ = ext_node($1, 1, mk_atom("Super")); } 1362| path_generic_args_with_colons MOD_SEP generic_args { $$ = ext_node($1, 1, $3); } 1363; 1364 1365// the braces-delimited macro is a block_expr so it doesn't appear here 1366macro_expr 1367: path_expr '!' maybe_ident parens_delimited_token_trees { $$ = mk_node("MacroExpr", 3, $1, $3, $4); } 1368| path_expr '!' maybe_ident brackets_delimited_token_trees { $$ = mk_node("MacroExpr", 3, $1, $3, $4); } 1369; 1370 1371nonblock_expr 1372: lit { $$ = mk_node("ExprLit", 1, $1); } 1373| %prec IDENT 1374 path_expr { $$ = mk_node("ExprPath", 1, $1); } 1375| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); } 1376| macro_expr { $$ = mk_node("ExprMac", 1, $1); } 1377| path_expr '{' struct_expr_fields '}' { $$ = mk_node("ExprStruct", 2, $1, $3); } 1378| nonblock_expr '?' { $$ = mk_node("ExprTry", 1, $1); } 1379| nonblock_expr '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); } 1380| nonblock_expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); } 1381| nonblock_expr '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); } 1382| nonblock_expr '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); } 1383| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); } 1384| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); } 1385| CONTINUE { $$ = mk_node("ExprAgain", 0); } 1386| CONTINUE lifetime { $$ = mk_node("ExprAgain", 1, $2); } 1387| RETURN { $$ = mk_node("ExprRet", 0); } 1388| RETURN expr { $$ = mk_node("ExprRet", 1, $2); } 1389| BREAK { $$ = mk_node("ExprBreak", 0); } 1390| BREAK lifetime { $$ = mk_node("ExprBreak", 1, $2); } 1391| YIELD { $$ = mk_node("ExprYield", 0); } 1392| YIELD expr { $$ = mk_node("ExprYield", 1, $2); } 1393| nonblock_expr '=' expr { $$ = mk_node("ExprAssign", 2, $1, $3); } 1394| nonblock_expr SHLEQ expr { $$ = mk_node("ExprAssignShl", 2, $1, $3); } 1395| nonblock_expr SHREQ expr { $$ = mk_node("ExprAssignShr", 2, $1, $3); } 1396| nonblock_expr MINUSEQ expr { $$ = mk_node("ExprAssignSub", 2, $1, $3); } 1397| nonblock_expr ANDEQ expr { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); } 1398| nonblock_expr OREQ expr { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); } 1399| nonblock_expr PLUSEQ expr { $$ = mk_node("ExprAssignAdd", 2, $1, $3); } 1400| nonblock_expr STAREQ expr { $$ = mk_node("ExprAssignMul", 2, $1, $3); } 1401| nonblock_expr SLASHEQ expr { $$ = mk_node("ExprAssignDiv", 2, $1, $3); } 1402| nonblock_expr CARETEQ expr { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); } 1403| nonblock_expr PERCENTEQ expr { $$ = mk_node("ExprAssignRem", 2, $1, $3); } 1404| nonblock_expr OROR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); } 1405| nonblock_expr ANDAND expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); } 1406| nonblock_expr EQEQ expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); } 1407| nonblock_expr NE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); } 1408| nonblock_expr '<' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); } 1409| nonblock_expr '>' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); } 1410| nonblock_expr LE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); } 1411| nonblock_expr GE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); } 1412| nonblock_expr '|' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); } 1413| nonblock_expr '^' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); } 1414| nonblock_expr '&' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); } 1415| nonblock_expr SHL expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); } 1416| nonblock_expr SHR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); } 1417| nonblock_expr '+' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); } 1418| nonblock_expr '-' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); } 1419| nonblock_expr '*' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); } 1420| nonblock_expr '/' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); } 1421| nonblock_expr '%' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); } 1422| nonblock_expr DOTDOT { $$ = mk_node("ExprRange", 2, $1, mk_none()); } 1423| nonblock_expr DOTDOT expr { $$ = mk_node("ExprRange", 2, $1, $3); } 1424| DOTDOT expr { $$ = mk_node("ExprRange", 2, mk_none(), $2); } 1425| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); } 1426| nonblock_expr AS ty { $$ = mk_node("ExprCast", 2, $1, $3); } 1427| nonblock_expr ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); } 1428| BOX expr { $$ = mk_node("ExprBox", 1, $2); } 1429| expr_qualified_path 1430| nonblock_prefix_expr 1431; 1432 1433expr 1434: lit { $$ = mk_node("ExprLit", 1, $1); } 1435| %prec IDENT 1436 path_expr { $$ = mk_node("ExprPath", 1, $1); } 1437| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); } 1438| macro_expr { $$ = mk_node("ExprMac", 1, $1); } 1439| path_expr '{' struct_expr_fields '}' { $$ = mk_node("ExprStruct", 2, $1, $3); } 1440| expr '?' { $$ = mk_node("ExprTry", 1, $1); } 1441| expr '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); } 1442| expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); } 1443| expr '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); } 1444| expr '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); } 1445| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); } 1446| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); } 1447| CONTINUE { $$ = mk_node("ExprAgain", 0); } 1448| CONTINUE ident { $$ = mk_node("ExprAgain", 1, $2); } 1449| RETURN { $$ = mk_node("ExprRet", 0); } 1450| RETURN expr { $$ = mk_node("ExprRet", 1, $2); } 1451| BREAK { $$ = mk_node("ExprBreak", 0); } 1452| BREAK ident { $$ = mk_node("ExprBreak", 1, $2); } 1453| YIELD { $$ = mk_node("ExprYield", 0); } 1454| YIELD expr { $$ = mk_node("ExprYield", 1, $2); } 1455| expr '=' expr { $$ = mk_node("ExprAssign", 2, $1, $3); } 1456| expr SHLEQ expr { $$ = mk_node("ExprAssignShl", 2, $1, $3); } 1457| expr SHREQ expr { $$ = mk_node("ExprAssignShr", 2, $1, $3); } 1458| expr MINUSEQ expr { $$ = mk_node("ExprAssignSub", 2, $1, $3); } 1459| expr ANDEQ expr { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); } 1460| expr OREQ expr { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); } 1461| expr PLUSEQ expr { $$ = mk_node("ExprAssignAdd", 2, $1, $3); } 1462| expr STAREQ expr { $$ = mk_node("ExprAssignMul", 2, $1, $3); } 1463| expr SLASHEQ expr { $$ = mk_node("ExprAssignDiv", 2, $1, $3); } 1464| expr CARETEQ expr { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); } 1465| expr PERCENTEQ expr { $$ = mk_node("ExprAssignRem", 2, $1, $3); } 1466| expr OROR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); } 1467| expr ANDAND expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); } 1468| expr EQEQ expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); } 1469| expr NE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); } 1470| expr '<' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); } 1471| expr '>' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); } 1472| expr LE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); } 1473| expr GE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); } 1474| expr '|' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); } 1475| expr '^' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); } 1476| expr '&' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); } 1477| expr SHL expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); } 1478| expr SHR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); } 1479| expr '+' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); } 1480| expr '-' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); } 1481| expr '*' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); } 1482| expr '/' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); } 1483| expr '%' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); } 1484| expr DOTDOT { $$ = mk_node("ExprRange", 2, $1, mk_none()); } 1485| expr DOTDOT expr { $$ = mk_node("ExprRange", 2, $1, $3); } 1486| DOTDOT expr { $$ = mk_node("ExprRange", 2, mk_none(), $2); } 1487| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); } 1488| expr AS ty { $$ = mk_node("ExprCast", 2, $1, $3); } 1489| expr ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); } 1490| BOX expr { $$ = mk_node("ExprBox", 1, $2); } 1491| expr_qualified_path 1492| block_expr 1493| block 1494| nonblock_prefix_expr 1495; 1496 1497expr_nostruct 1498: lit { $$ = mk_node("ExprLit", 1, $1); } 1499| %prec IDENT 1500 path_expr { $$ = mk_node("ExprPath", 1, $1); } 1501| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); } 1502| macro_expr { $$ = mk_node("ExprMac", 1, $1); } 1503| expr_nostruct '?' { $$ = mk_node("ExprTry", 1, $1); } 1504| expr_nostruct '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); } 1505| expr_nostruct '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); } 1506| expr_nostruct '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); } 1507| expr_nostruct '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); } 1508| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); } 1509| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); } 1510| CONTINUE { $$ = mk_node("ExprAgain", 0); } 1511| CONTINUE ident { $$ = mk_node("ExprAgain", 1, $2); } 1512| RETURN { $$ = mk_node("ExprRet", 0); } 1513| RETURN expr { $$ = mk_node("ExprRet", 1, $2); } 1514| BREAK { $$ = mk_node("ExprBreak", 0); } 1515| BREAK ident { $$ = mk_node("ExprBreak", 1, $2); } 1516| YIELD { $$ = mk_node("ExprYield", 0); } 1517| YIELD expr { $$ = mk_node("ExprYield", 1, $2); } 1518| expr_nostruct '=' expr_nostruct { $$ = mk_node("ExprAssign", 2, $1, $3); } 1519| expr_nostruct SHLEQ expr_nostruct { $$ = mk_node("ExprAssignShl", 2, $1, $3); } 1520| expr_nostruct SHREQ expr_nostruct { $$ = mk_node("ExprAssignShr", 2, $1, $3); } 1521| expr_nostruct MINUSEQ expr_nostruct { $$ = mk_node("ExprAssignSub", 2, $1, $3); } 1522| expr_nostruct ANDEQ expr_nostruct { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); } 1523| expr_nostruct OREQ expr_nostruct { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); } 1524| expr_nostruct PLUSEQ expr_nostruct { $$ = mk_node("ExprAssignAdd", 2, $1, $3); } 1525| expr_nostruct STAREQ expr_nostruct { $$ = mk_node("ExprAssignMul", 2, $1, $3); } 1526| expr_nostruct SLASHEQ expr_nostruct { $$ = mk_node("ExprAssignDiv", 2, $1, $3); } 1527| expr_nostruct CARETEQ expr_nostruct { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); } 1528| expr_nostruct PERCENTEQ expr_nostruct { $$ = mk_node("ExprAssignRem", 2, $1, $3); } 1529| expr_nostruct OROR expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); } 1530| expr_nostruct ANDAND expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); } 1531| expr_nostruct EQEQ expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); } 1532| expr_nostruct NE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); } 1533| expr_nostruct '<' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); } 1534| expr_nostruct '>' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); } 1535| expr_nostruct LE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); } 1536| expr_nostruct GE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); } 1537| expr_nostruct '|' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); } 1538| expr_nostruct '^' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); } 1539| expr_nostruct '&' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); } 1540| expr_nostruct SHL expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); } 1541| expr_nostruct SHR expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); } 1542| expr_nostruct '+' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); } 1543| expr_nostruct '-' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); } 1544| expr_nostruct '*' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); } 1545| expr_nostruct '/' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); } 1546| expr_nostruct '%' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); } 1547| expr_nostruct DOTDOT %prec RANGE { $$ = mk_node("ExprRange", 2, $1, mk_none()); } 1548| expr_nostruct DOTDOT expr_nostruct { $$ = mk_node("ExprRange", 2, $1, $3); } 1549| DOTDOT expr_nostruct { $$ = mk_node("ExprRange", 2, mk_none(), $2); } 1550| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); } 1551| expr_nostruct AS ty { $$ = mk_node("ExprCast", 2, $1, $3); } 1552| expr_nostruct ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); } 1553| BOX expr { $$ = mk_node("ExprBox", 1, $2); } 1554| expr_qualified_path 1555| block_expr 1556| block 1557| nonblock_prefix_expr_nostruct 1558; 1559 1560nonblock_prefix_expr_nostruct 1561: '-' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnNeg"), $2); } 1562| '!' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnNot"), $2); } 1563| '*' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnDeref"), $2); } 1564| '&' maybe_mut expr_nostruct { $$ = mk_node("ExprAddrOf", 2, $2, $3); } 1565| ANDAND maybe_mut expr_nostruct { $$ = mk_node("ExprAddrOf", 1, mk_node("ExprAddrOf", 2, $2, $3)); } 1566| lambda_expr_nostruct 1567| MOVE lambda_expr_nostruct { $$ = $2; } 1568; 1569 1570nonblock_prefix_expr 1571: '-' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnNeg"), $2); } 1572| '!' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnNot"), $2); } 1573| '*' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnDeref"), $2); } 1574| '&' maybe_mut expr { $$ = mk_node("ExprAddrOf", 2, $2, $3); } 1575| ANDAND maybe_mut expr { $$ = mk_node("ExprAddrOf", 1, mk_node("ExprAddrOf", 2, $2, $3)); } 1576| lambda_expr 1577| MOVE lambda_expr { $$ = $2; } 1578; 1579 1580expr_qualified_path 1581: '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_qpath_params 1582{ 1583 $$ = mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7); 1584} 1585| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident 1586{ 1587 $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10); 1588} 1589| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident 1590{ 1591 $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11); 1592} 1593| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident generic_args 1594{ 1595 $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10, $11); 1596} 1597| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident generic_args 1598{ 1599 $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11, $12); 1600} 1601 1602maybe_qpath_params 1603: MOD_SEP generic_args { $$ = $2; } 1604| %empty { $$ = mk_none(); } 1605; 1606 1607maybe_as_trait_ref 1608: AS trait_ref { $$ = $2; } 1609| %empty { $$ = mk_none(); } 1610; 1611 1612lambda_expr 1613: %prec LAMBDA 1614 OROR ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); } 1615| %prec LAMBDA 1616 '|' '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $3, $4); } 1617| %prec LAMBDA 1618 '|' inferrable_params '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, $2, $4, $5); } 1619| %prec LAMBDA 1620 '|' inferrable_params OROR lambda_expr_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $2, mk_none(), $4); } 1621; 1622 1623lambda_expr_no_first_bar 1624: %prec LAMBDA 1625 '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); } 1626| %prec LAMBDA 1627 inferrable_params '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, $1, $3, $4); } 1628| %prec LAMBDA 1629 inferrable_params OROR lambda_expr_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $1, mk_none(), $3); } 1630; 1631 1632lambda_expr_nostruct 1633: %prec LAMBDA 1634 OROR expr_nostruct { $$ = mk_node("ExprFnBlock", 2, mk_none(), $2); } 1635| %prec LAMBDA 1636 '|' '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, mk_none(), $3, $4); } 1637| %prec LAMBDA 1638 '|' inferrable_params '|' expr_nostruct { $$ = mk_node("ExprFnBlock", 2, $2, $4); } 1639| %prec LAMBDA 1640 '|' inferrable_params OROR lambda_expr_nostruct_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $2, mk_none(), $4); } 1641; 1642 1643lambda_expr_nostruct_no_first_bar 1644: %prec LAMBDA 1645 '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); } 1646| %prec LAMBDA 1647 inferrable_params '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, $1, $3, $4); } 1648| %prec LAMBDA 1649 inferrable_params OROR lambda_expr_nostruct_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $1, mk_none(), $3); } 1650; 1651 1652vec_expr 1653: maybe_exprs 1654| exprs ';' expr { $$ = mk_node("VecRepeat", 2, $1, $3); } 1655; 1656 1657struct_expr_fields 1658: field_inits 1659| field_inits ',' 1660| maybe_field_inits default_field_init { $$ = ext_node($1, 1, $2); } 1661| %empty { $$ = mk_none(); } 1662; 1663 1664maybe_field_inits 1665: field_inits 1666| field_inits ',' 1667| %empty { $$ = mk_none(); } 1668; 1669 1670field_inits 1671: field_init { $$ = mk_node("FieldInits", 1, $1); } 1672| field_inits ',' field_init { $$ = ext_node($1, 1, $3); } 1673; 1674 1675field_init 1676: ident { $$ = mk_node("FieldInit", 1, $1); } 1677| ident ':' expr { $$ = mk_node("FieldInit", 2, $1, $3); } 1678| LIT_INTEGER ':' expr { $$ = mk_node("FieldInit", 2, mk_atom(yytext), $3); } 1679; 1680 1681default_field_init 1682: DOTDOT expr { $$ = mk_node("DefaultFieldInit", 1, $2); } 1683; 1684 1685block_expr 1686: expr_match 1687| expr_if 1688| expr_if_let 1689| expr_while 1690| expr_while_let 1691| expr_loop 1692| expr_for 1693| UNSAFE block { $$ = mk_node("UnsafeBlock", 1, $2); } 1694| path_expr '!' maybe_ident braces_delimited_token_trees { $$ = mk_node("Macro", 3, $1, $3, $4); } 1695; 1696 1697full_block_expr 1698: block_expr 1699| block_expr_dot 1700; 1701 1702block_expr_dot 1703: block_expr '.' path_generic_args_with_colons %prec IDENT { $$ = mk_node("ExprField", 2, $1, $3); } 1704| block_expr_dot '.' path_generic_args_with_colons %prec IDENT { $$ = mk_node("ExprField", 2, $1, $3); } 1705| block_expr '.' path_generic_args_with_colons '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 3, $1, $3, $5); } 1706| block_expr_dot '.' path_generic_args_with_colons '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 3, $1, $3, $5); } 1707| block_expr '.' path_generic_args_with_colons '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 3, $1, $3, $5); } 1708| block_expr_dot '.' path_generic_args_with_colons '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 3, $1, $3, $5); } 1709| block_expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); } 1710| block_expr_dot '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); } 1711; 1712 1713expr_match 1714: MATCH expr_nostruct '{' '}' { $$ = mk_node("ExprMatch", 1, $2); } 1715| MATCH expr_nostruct '{' match_clauses '}' { $$ = mk_node("ExprMatch", 2, $2, $4); } 1716| MATCH expr_nostruct '{' match_clauses nonblock_match_clause '}' { $$ = mk_node("ExprMatch", 2, $2, ext_node($4, 1, $5)); } 1717| MATCH expr_nostruct '{' nonblock_match_clause '}' { $$ = mk_node("ExprMatch", 2, $2, mk_node("Arms", 1, $4)); } 1718; 1719 1720match_clauses 1721: match_clause { $$ = mk_node("Arms", 1, $1); } 1722| match_clauses match_clause { $$ = ext_node($1, 1, $2); } 1723; 1724 1725match_clause 1726: nonblock_match_clause ',' 1727| block_match_clause 1728| block_match_clause ',' 1729; 1730 1731nonblock_match_clause 1732: maybe_outer_attrs pats_or maybe_guard FAT_ARROW nonblock_expr { $$ = mk_node("ArmNonblock", 4, $1, $2, $3, $5); } 1733| maybe_outer_attrs pats_or maybe_guard FAT_ARROW block_expr_dot { $$ = mk_node("ArmNonblock", 4, $1, $2, $3, $5); } 1734; 1735 1736block_match_clause 1737: maybe_outer_attrs pats_or maybe_guard FAT_ARROW block { $$ = mk_node("ArmBlock", 4, $1, $2, $3, $5); } 1738| maybe_outer_attrs pats_or maybe_guard FAT_ARROW block_expr { $$ = mk_node("ArmBlock", 4, $1, $2, $3, $5); } 1739; 1740 1741maybe_guard 1742: IF expr_nostruct { $$ = $2; } 1743| %empty { $$ = mk_none(); } 1744; 1745 1746expr_if 1747: IF expr_nostruct block { $$ = mk_node("ExprIf", 2, $2, $3); } 1748| IF expr_nostruct block ELSE block_or_if { $$ = mk_node("ExprIf", 3, $2, $3, $5); } 1749; 1750 1751expr_if_let 1752: IF LET pat '=' expr_nostruct block { $$ = mk_node("ExprIfLet", 3, $3, $5, $6); } 1753| IF LET pat '=' expr_nostruct block ELSE block_or_if { $$ = mk_node("ExprIfLet", 4, $3, $5, $6, $8); } 1754; 1755 1756block_or_if 1757: block 1758| expr_if 1759| expr_if_let 1760; 1761 1762expr_while 1763: maybe_label WHILE expr_nostruct block { $$ = mk_node("ExprWhile", 3, $1, $3, $4); } 1764; 1765 1766expr_while_let 1767: maybe_label WHILE LET pat '=' expr_nostruct block { $$ = mk_node("ExprWhileLet", 4, $1, $4, $6, $7); } 1768; 1769 1770expr_loop 1771: maybe_label LOOP block { $$ = mk_node("ExprLoop", 2, $1, $3); } 1772; 1773 1774expr_for 1775: maybe_label FOR pat IN expr_nostruct block { $$ = mk_node("ExprForLoop", 4, $1, $3, $5, $6); } 1776; 1777 1778maybe_label 1779: lifetime ':' 1780| %empty { $$ = mk_none(); } 1781; 1782 1783let 1784: LET pat maybe_ty_ascription maybe_init_expr ';' { $$ = mk_node("DeclLocal", 3, $2, $3, $4); } 1785; 1786 1787//////////////////////////////////////////////////////////////////////// 1788// Part 5: Macros and misc. rules 1789//////////////////////////////////////////////////////////////////////// 1790 1791lit 1792: LIT_BYTE { $$ = mk_node("LitByte", 1, mk_atom(yytext)); } 1793| LIT_CHAR { $$ = mk_node("LitChar", 1, mk_atom(yytext)); } 1794| LIT_INTEGER { $$ = mk_node("LitInteger", 1, mk_atom(yytext)); } 1795| LIT_FLOAT { $$ = mk_node("LitFloat", 1, mk_atom(yytext)); } 1796| TRUE { $$ = mk_node("LitBool", 1, mk_atom(yytext)); } 1797| FALSE { $$ = mk_node("LitBool", 1, mk_atom(yytext)); } 1798| str 1799; 1800 1801str 1802: LIT_STR { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("CookedStr")); } 1803| LIT_STR_RAW { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("RawStr")); } 1804| LIT_BYTE_STR { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("ByteStr")); } 1805| LIT_BYTE_STR_RAW { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("RawByteStr")); } 1806; 1807 1808maybe_ident 1809: %empty { $$ = mk_none(); } 1810| ident 1811; 1812 1813ident 1814: IDENT { $$ = mk_node("ident", 1, mk_atom(yytext)); } 1815// Weak keywords that can be used as identifiers 1816| CATCH { $$ = mk_node("ident", 1, mk_atom(yytext)); } 1817| DEFAULT { $$ = mk_node("ident", 1, mk_atom(yytext)); } 1818| UNION { $$ = mk_node("ident", 1, mk_atom(yytext)); } 1819; 1820 1821unpaired_token 1822: SHL { $$ = mk_atom(yytext); } 1823| SHR { $$ = mk_atom(yytext); } 1824| LE { $$ = mk_atom(yytext); } 1825| EQEQ { $$ = mk_atom(yytext); } 1826| NE { $$ = mk_atom(yytext); } 1827| GE { $$ = mk_atom(yytext); } 1828| ANDAND { $$ = mk_atom(yytext); } 1829| OROR { $$ = mk_atom(yytext); } 1830| LARROW { $$ = mk_atom(yytext); } 1831| SHLEQ { $$ = mk_atom(yytext); } 1832| SHREQ { $$ = mk_atom(yytext); } 1833| MINUSEQ { $$ = mk_atom(yytext); } 1834| ANDEQ { $$ = mk_atom(yytext); } 1835| OREQ { $$ = mk_atom(yytext); } 1836| PLUSEQ { $$ = mk_atom(yytext); } 1837| STAREQ { $$ = mk_atom(yytext); } 1838| SLASHEQ { $$ = mk_atom(yytext); } 1839| CARETEQ { $$ = mk_atom(yytext); } 1840| PERCENTEQ { $$ = mk_atom(yytext); } 1841| DOTDOT { $$ = mk_atom(yytext); } 1842| DOTDOTDOT { $$ = mk_atom(yytext); } 1843| MOD_SEP { $$ = mk_atom(yytext); } 1844| RARROW { $$ = mk_atom(yytext); } 1845| FAT_ARROW { $$ = mk_atom(yytext); } 1846| LIT_BYTE { $$ = mk_atom(yytext); } 1847| LIT_CHAR { $$ = mk_atom(yytext); } 1848| LIT_INTEGER { $$ = mk_atom(yytext); } 1849| LIT_FLOAT { $$ = mk_atom(yytext); } 1850| LIT_STR { $$ = mk_atom(yytext); } 1851| LIT_STR_RAW { $$ = mk_atom(yytext); } 1852| LIT_BYTE_STR { $$ = mk_atom(yytext); } 1853| LIT_BYTE_STR_RAW { $$ = mk_atom(yytext); } 1854| IDENT { $$ = mk_atom(yytext); } 1855| UNDERSCORE { $$ = mk_atom(yytext); } 1856| LIFETIME { $$ = mk_atom(yytext); } 1857| SELF { $$ = mk_atom(yytext); } 1858| STATIC { $$ = mk_atom(yytext); } 1859| ABSTRACT { $$ = mk_atom(yytext); } 1860| ALIGNOF { $$ = mk_atom(yytext); } 1861| AS { $$ = mk_atom(yytext); } 1862| BECOME { $$ = mk_atom(yytext); } 1863| BREAK { $$ = mk_atom(yytext); } 1864| CATCH { $$ = mk_atom(yytext); } 1865| CRATE { $$ = mk_atom(yytext); } 1866| DEFAULT { $$ = mk_atom(yytext); } 1867| DO { $$ = mk_atom(yytext); } 1868| ELSE { $$ = mk_atom(yytext); } 1869| ENUM { $$ = mk_atom(yytext); } 1870| EXTERN { $$ = mk_atom(yytext); } 1871| FALSE { $$ = mk_atom(yytext); } 1872| FINAL { $$ = mk_atom(yytext); } 1873| FN { $$ = mk_atom(yytext); } 1874| FOR { $$ = mk_atom(yytext); } 1875| IF { $$ = mk_atom(yytext); } 1876| IMPL { $$ = mk_atom(yytext); } 1877| IN { $$ = mk_atom(yytext); } 1878| LET { $$ = mk_atom(yytext); } 1879| LOOP { $$ = mk_atom(yytext); } 1880| MACRO { $$ = mk_atom(yytext); } 1881| MATCH { $$ = mk_atom(yytext); } 1882| MOD { $$ = mk_atom(yytext); } 1883| MOVE { $$ = mk_atom(yytext); } 1884| MUT { $$ = mk_atom(yytext); } 1885| OFFSETOF { $$ = mk_atom(yytext); } 1886| OVERRIDE { $$ = mk_atom(yytext); } 1887| PRIV { $$ = mk_atom(yytext); } 1888| PUB { $$ = mk_atom(yytext); } 1889| PURE { $$ = mk_atom(yytext); } 1890| REF { $$ = mk_atom(yytext); } 1891| RETURN { $$ = mk_atom(yytext); } 1892| STRUCT { $$ = mk_atom(yytext); } 1893| SIZEOF { $$ = mk_atom(yytext); } 1894| SUPER { $$ = mk_atom(yytext); } 1895| TRUE { $$ = mk_atom(yytext); } 1896| TRAIT { $$ = mk_atom(yytext); } 1897| TYPE { $$ = mk_atom(yytext); } 1898| UNION { $$ = mk_atom(yytext); } 1899| UNSAFE { $$ = mk_atom(yytext); } 1900| UNSIZED { $$ = mk_atom(yytext); } 1901| USE { $$ = mk_atom(yytext); } 1902| VIRTUAL { $$ = mk_atom(yytext); } 1903| WHILE { $$ = mk_atom(yytext); } 1904| YIELD { $$ = mk_atom(yytext); } 1905| CONTINUE { $$ = mk_atom(yytext); } 1906| PROC { $$ = mk_atom(yytext); } 1907| BOX { $$ = mk_atom(yytext); } 1908| CONST { $$ = mk_atom(yytext); } 1909| WHERE { $$ = mk_atom(yytext); } 1910| TYPEOF { $$ = mk_atom(yytext); } 1911| INNER_DOC_COMMENT { $$ = mk_atom(yytext); } 1912| OUTER_DOC_COMMENT { $$ = mk_atom(yytext); } 1913| SHEBANG { $$ = mk_atom(yytext); } 1914| STATIC_LIFETIME { $$ = mk_atom(yytext); } 1915| ';' { $$ = mk_atom(yytext); } 1916| ',' { $$ = mk_atom(yytext); } 1917| '.' { $$ = mk_atom(yytext); } 1918| '@' { $$ = mk_atom(yytext); } 1919| '#' { $$ = mk_atom(yytext); } 1920| '~' { $$ = mk_atom(yytext); } 1921| ':' { $$ = mk_atom(yytext); } 1922| '$' { $$ = mk_atom(yytext); } 1923| '=' { $$ = mk_atom(yytext); } 1924| '?' { $$ = mk_atom(yytext); } 1925| '!' { $$ = mk_atom(yytext); } 1926| '<' { $$ = mk_atom(yytext); } 1927| '>' { $$ = mk_atom(yytext); } 1928| '-' { $$ = mk_atom(yytext); } 1929| '&' { $$ = mk_atom(yytext); } 1930| '|' { $$ = mk_atom(yytext); } 1931| '+' { $$ = mk_atom(yytext); } 1932| '*' { $$ = mk_atom(yytext); } 1933| '/' { $$ = mk_atom(yytext); } 1934| '^' { $$ = mk_atom(yytext); } 1935| '%' { $$ = mk_atom(yytext); } 1936; 1937 1938token_trees 1939: %empty { $$ = mk_node("TokenTrees", 0); } 1940| token_trees token_tree { $$ = ext_node($1, 1, $2); } 1941; 1942 1943token_tree 1944: delimited_token_trees 1945| unpaired_token { $$ = mk_node("TTTok", 1, $1); } 1946; 1947 1948delimited_token_trees 1949: parens_delimited_token_trees 1950| braces_delimited_token_trees 1951| brackets_delimited_token_trees 1952; 1953 1954parens_delimited_token_trees 1955: '(' token_trees ')' 1956{ 1957 $$ = mk_node("TTDelim", 3, 1958 mk_node("TTTok", 1, mk_atom("(")), 1959 $2, 1960 mk_node("TTTok", 1, mk_atom(")"))); 1961} 1962; 1963 1964braces_delimited_token_trees 1965: '{' token_trees '}' 1966{ 1967 $$ = mk_node("TTDelim", 3, 1968 mk_node("TTTok", 1, mk_atom("{")), 1969 $2, 1970 mk_node("TTTok", 1, mk_atom("}"))); 1971} 1972; 1973 1974brackets_delimited_token_trees 1975: '[' token_trees ']' 1976{ 1977 $$ = mk_node("TTDelim", 3, 1978 mk_node("TTTok", 1, mk_atom("[")), 1979 $2, 1980 mk_node("TTTok", 1, mk_atom("]"))); 1981} 1982;