src/grammar/parser-lalr.y

   1 %{
   2 #define YYERROR_VERBOSE
   3 #define YYSTYPE struct node *
   4 struct node;
   5 extern int yylex();
   6 extern void yyerror(char const *s);
   7 extern struct node *mk_node(char const *name, int n, ...);
   8 extern struct node *mk_atom(char *text);
   9 extern struct node *mk_none();
  10 extern struct node *ext_node(struct node *nd, int n, ...);
  11 extern void push_back(char c);
  12 extern 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
 209 crate
 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
 214 maybe_shebang
 215 : SHEBANG_LINE
 216 | %empty
 217 ;
 218
 219 maybe_inner_attrs
 220 : inner_attrs
 221 | %empty                   { $$ = mk_none(); }
 222 ;
 223
 224 inner_attrs
 225 : inner_attr               { $$ = mk_node("InnerAttrs", 1, $1); }
 226 | inner_attrs inner_attr   { $$ = ext_node($1, 1, $2); }
 227 ;
 228
 229 inner_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
 234 maybe_outer_attrs
 235 : outer_attrs
 236 | %empty                   { $$ = mk_none(); }
 237 ;
 238
 239 outer_attrs
 240 : outer_attr               { $$ = mk_node("OuterAttrs", 1, $1); }
 241 | outer_attrs outer_attr   { $$ = ext_node($1, 1, $2); }
 242 ;
 243
 244 outer_attr
 245 : '#' '[' meta_item ']'    { $$ = $3; }
 246 | OUTER_DOC_COMMENT        { $$ = mk_node("doc-comment", 1, mk_atom(yytext)); }
 247 ;
 248
 249 meta_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
 256 meta_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
 262 maybe_mod_items
 263 : mod_items
 264 | %empty             { $$ = mk_none(); }
 265 ;
 266
 267 mod_items
 268 : mod_item                               { $$ = mk_node("Items", 1, $1); }
 269 | mod_items mod_item                     { $$ = ext_node($1, 1, $2); }
 270 ;
 271
 272 attrs_and_vis
 273 : maybe_outer_attrs visibility           { $$ = mk_node("AttrsAndVis", 2, $1, $2); }
 274 ;
 275
 276 mod_item
 277 : attrs_and_vis item    { $$ = mk_node("Item", 2, $1, $2); }
 278 ;
 279
 280 // items that can appear outside of a fn block
 281 item
 282 : stmt_item
 283 | item_macro
 284 ;
 285
 286 // items that can appear in "stmts"
 287 stmt_item
 288 : item_static
 289 | item_const
 290 | item_type
 291 | block_item
 292 | view_item
 293 ;
 294
 295 item_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
 300 item_const
 301 : CONST ident ':' ty '=' expr ';'  { $$ = mk_node("ItemConst", 3, $2, $4, $6); }
 302 ;
 303
 304 item_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
 310 view_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
 317 extern_fn_item
 318 : EXTERN maybe_abi item_fn                    { $$ = mk_node("ViewItemExternFn", 2, $2, $3); }
 319 ;
 320
 321 use_item
 322 : USE view_path ';'                           { $$ = mk_node("ViewItemUse", 1, $2); }
 323 ;
 324
 325 view_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
 342 block_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
 354 maybe_ty_ascription
 355 : ':' ty_sum { $$ = $2; }
 356 | %empty { $$ = mk_none(); }
 357 ;
 358
 359 maybe_init_expr
 360 : '=' expr { $$ = $2; }
 361 | %empty   { $$ = mk_none(); }
 362 ;
 363
 364 // structs
 365 item_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
 380 struct_decl_args
 381 : '{' struct_decl_fields '}'                  { $$ = $2; }
 382 | '{' struct_decl_fields ',' '}'              { $$ = $2; }
 383 ;
 384
 385 struct_tuple_args
 386 : '(' struct_tuple_fields ')'                 { $$ = $2; }
 387 | '(' struct_tuple_fields ',' ')'             { $$ = $2; }
 388 ;
 389
 390 struct_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
 396 struct_decl_field
 397 : attrs_and_vis ident ':' ty_sum              { $$ = mk_node("StructField", 3, $1, $2, $4); }
 398 ;
 399
 400 struct_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
 406 struct_tuple_field
 407 : attrs_and_vis ty_sum                    { $$ = mk_node("StructField", 2, $1, $2); }
 408 ;
 409
 410 // enums
 411 item_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
 416 enum_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
 422 enum_def
 423 : attrs_and_vis ident enum_args { $$ = mk_node("EnumDef", 3, $1, $2, $3); }
 424 ;
 425
 426 enum_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
 435 item_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
 439 item_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
 445 item_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
 450 maybe_abi
 451 : str
 452 | %empty { $$ = mk_none(); }
 453 ;
 454
 455 maybe_foreign_items
 456 : foreign_items
 457 | %empty { $$ = mk_none(); }
 458 ;
 459
 460 foreign_items
 461 : foreign_item               { $$ = mk_node("ForeignItems", 1, $1); }
 462 | foreign_items foreign_item { $$ = ext_node($1, 1, $2); }
 463 ;
 464
 465 foreign_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
 471 item_foreign_static
 472 : maybe_mut ident ':' ty ';'               { $$ = mk_node("StaticItem", 3, $1, $2, $4); }
 473 ;
 474
 475 item_foreign_fn
 476 : FN ident generic_params fn_decl_allow_variadic maybe_where_clause ';' { $$ = mk_node("ForeignFn", 4, $2, $3, $4, $5); }
 477 ;
 478
 479 fn_decl_allow_variadic
 480 : fn_params_allow_variadic ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); }
 481 ;
 482
 483 fn_params_allow_variadic
 484 : '(' ')'                      { $$ = mk_none(); }
 485 | '(' params ')'               { $$ = $2; }
 486 | '(' params ',' ')'           { $$ = $2; }
 487 | '(' params ',' DOTDOTDOT ')' { $$ = $2; }
 488 ;
 489
 490 visibility
 491 : PUB      { $$ = mk_atom("Public"); }
 492 | %empty   { $$ = mk_atom("Inherited"); }
 493 ;
 494
 495 idents_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
 501 ident_or_self
 502 : ident
 503 | SELF  { $$ = mk_atom(yytext); }
 504 ;
 505
 506 item_type
 507 : TYPE ident generic_params maybe_where_clause '=' ty_sum ';'  { $$ = mk_node("ItemTy", 4, $2, $3, $4, $6); }
 508 ;
 509
 510 for_sized
 511 : FOR '?' ident { $$ = mk_node("ForSized", 1, $3); }
 512 | FOR ident '?' { $$ = mk_node("ForSized", 1, $2); }
 513 | %empty        { $$ = mk_none(); }
 514 ;
 515
 516 item_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
 523 maybe_trait_items
 524 : trait_items
 525 | %empty { $$ = mk_none(); }
 526 ;
 527
 528 trait_items
 529 : trait_item               { $$ = mk_node("TraitItems", 1, $1); }
 530 | trait_items trait_item   { $$ = ext_node($1, 1, $2); }
 531 ;
 532
 533 trait_item
 534 : trait_const
 535 | trait_type
 536 | trait_method
 537 | maybe_outer_attrs item_macro { $$ = mk_node("TraitMacroItem", 2, $1, $2); }
 538 ;
 539
 540 trait_const
 541 : maybe_outer_attrs CONST ident maybe_ty_ascription maybe_const_default ';' { $$ = mk_node("ConstTraitItem", 4, $1, $3, $4, $5); }
 542 ;
 543
 544 maybe_const_default
 545 : '=' expr { $$ = mk_node("ConstDefault", 1, $2); }
 546 | %empty   { $$ = mk_none(); }
 547 ;
 548
 549 trait_type
 550 : maybe_outer_attrs TYPE ty_param ';' { $$ = mk_node("TypeTraitItem", 2, $1, $3); }
 551 ;
 552
 553 maybe_unsafe
 554 : UNSAFE { $$ = mk_atom("Unsafe"); }
 555 | %empty { $$ = mk_none(); }
 556 ;
 557
 558 maybe_default_maybe_unsafe
 559 : DEFAULT UNSAFE { $$ = mk_atom("DefaultUnsafe"); }
 560 | DEFAULT        { $$ = mk_atom("Default"); }
 561 |         UNSAFE { $$ = mk_atom("Unsafe"); }
 562 | %empty { $$ = mk_none(); }
 563
 564 trait_method
 565 : type_method { $$ = mk_node("Required", 1, $1); }
 566 | method      { $$ = mk_node("Provided", 1, $1); }
 567 ;
 568
 569 type_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
 584 method
 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
 599 impl_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.
 629 item_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
 656 maybe_impl_items
 657 : impl_items
 658 | %empty { $$ = mk_none(); }
 659 ;
 660
 661 impl_items
 662 : impl_item               { $$ = mk_node("ImplItems", 1, $1); }
 663 | impl_item impl_items    { $$ = ext_node($1, 1, $2); }
 664 ;
 665
 666 impl_item
 667 : impl_method
 668 | attrs_and_vis item_macro { $$ = mk_node("ImplMacroItem", 2, $1, $2); }
 669 | impl_const
 670 | impl_type
 671 ;
 672
 673 maybe_default
 674 : DEFAULT { $$ = mk_atom("Default"); }
 675 | %empty { $$ = mk_none(); }
 676 ;
 677
 678 impl_const
 679 : attrs_and_vis maybe_default item_const { $$ = mk_node("ImplConst", 3, $1, $2, $3); }
 680 ;
 681
 682 impl_type
 683 : attrs_and_vis maybe_default TYPE ident generic_params '=' ty_sum ';'  { $$ = mk_node("ImplType", 5, $1, $2, $4, $5, $7); }
 684 ;
 685
 686 item_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
 697 item_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
 712 fn_decl
 713 : fn_params ret_ty   { $$ = mk_node("FnDecl", 2, $1, $2); }
 714 ;
 715
 716 fn_decl_with_self
 717 : fn_params_with_self ret_ty   { $$ = mk_node("FnDecl", 2, $1, $2); }
 718 ;
 719
 720 fn_decl_with_self_allow_anon_params
 721 : fn_anon_params_with_self ret_ty   { $$ = mk_node("FnDecl", 2, $1, $2); }
 722 ;
 723
 724 fn_params
 725 : '(' maybe_params ')'  { $$ = $2; }
 726 ;
 727
 728 fn_anon_params
 729 : '(' anon_param anon_params_allow_variadic_tail ')' { $$ = ext_node($2, 1, $3); }
 730 | '(' ')'                                            { $$ = mk_none(); }
 731 ;
 732
 733 fn_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
 740 fn_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
 747 maybe_params
 748 : params
 749 | params ','
 750 | %empty  { $$ = mk_none(); }
 751 ;
 752
 753 params
 754 : param                { $$ = mk_node("Args", 1, $1); }
 755 | params ',' param     { $$ = ext_node($1, 1, $3); }
 756 ;
 757
 758 param
 759 : pat ':' ty_sum   { $$ = mk_node("Arg", 2, $1, $3); }
 760 ;
 761
 762 inferrable_params
 763 : inferrable_param                       { $$ = mk_node("InferrableParams", 1, $1); }
 764 | inferrable_params ',' inferrable_param { $$ = ext_node($1, 1, $3); }
 765 ;
 766
 767 inferrable_param
 768 : pat maybe_ty_ascription { $$ = mk_node("InferrableParam", 2, $1, $2); }
 769 ;
 770
 771 maybe_comma_params
 772 : ','            { $$ = mk_none(); }
 773 | ',' params     { $$ = $2; }
 774 | ',' params ',' { $$ = $2; }
 775 | %empty         { $$ = mk_none(); }
 776 ;
 777
 778 maybe_comma_anon_params
 779 : ','                 { $$ = mk_none(); }
 780 | ',' anon_params     { $$ = $2; }
 781 | ',' anon_params ',' { $$ = $2; }
 782 | %empty              { $$ = mk_none(); }
 783 ;
 784
 785 maybe_anon_params
 786 : anon_params
 787 | anon_params ','
 788 | %empty      { $$ = mk_none(); }
 789 ;
 790
 791 anon_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
 798 anon_param
 799 : named_arg ':' ty   { $$ = mk_node("Arg", 2, $1, $3); }
 800 | ty
 801 ;
 802
 803 anon_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
 809 named_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
 819 ret_ty
 820 : RARROW '!'         { $$ = mk_none(); }
 821 | RARROW ty          { $$ = mk_node("ret-ty", 1, $2); }
 822 | %prec IDENT %empty { $$ = mk_none(); }
 823 ;
 824
 825 generic_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
 842 maybe_where_clause
 843 : %empty                              { $$ = mk_none(); }
 844 | where_clause
 845 ;
 846
 847 where_clause
 848 : WHERE where_predicates              { $$ = mk_node("WhereClause", 1, $2); }
 849 | WHERE where_predicates ','          { $$ = mk_node("WhereClause", 1, $2); }
 850 ;
 851
 852 where_predicates
 853 : where_predicate                      { $$ = mk_node("WherePredicates", 1, $1); }
 854 | where_predicates ',' where_predicate { $$ = ext_node($1, 1, $3); }
 855 ;
 856
 857 where_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
 862 maybe_for_lifetimes
 863 : FOR '<' lifetimes '>' { $$ = mk_none(); }
 864 | %prec FORTYPE %empty  { $$ = mk_none(); }
 865
 866 ty_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.
 875 path_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.
 896 path_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
 911 generic_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
 926 generic_values
 927 : maybe_ty_sums_and_or_bindings { $$ = mk_node("GenericValues", 1, $1); }
 928 ;
 929
 930 maybe_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
 939 maybe_bindings
 940 : ',' bindings { $$ = $2; }
 941 | %empty       { $$ = mk_none(); }
 942 ;
 943
 944 ////////////////////////////////////////////////////////////////////////
 945 // Part 2: Patterns
 946 ////////////////////////////////////////////////////////////////////////
 947
 948 pat
 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
 973 pats_or
 974 : pat              { $$ = mk_node("Pats", 1, $1); }
 975 | pats_or '|' pat  { $$ = ext_node($1, 1, $3); }
 976 ;
 977
 978 binding_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
 984 lit_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
 990 pat_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
1000 pat_fields
1001 : pat_field                  { $$ = mk_node("PatFields", 1, $1); }
1002 | pat_fields ',' pat_field   { $$ = ext_node($1, 1, $3); }
1003 ;
1004
1005 pat_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
1013 pat_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
1027 pat_tup_elts
1028 : pat                    { $$ = mk_node("PatTupElts", 1, $1); }
1029 | pat_tup_elts ',' pat   { $$ = ext_node($1, 1, $3); }
1030 ;
1031
1032 pat_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
1047 pat_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
1056 ty
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
1066 ty_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
1089 ty_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
1096 ty_fn_decl
1097 : generic_params fn_anon_params ret_ty { $$ = mk_node("TyFnDecl", 3, $1, $2, $3); }
1098 ;
1099
1100 ty_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
1107 for_in_type
1108 : FOR '<' maybe_lifetimes '>' for_in_type_suffix { $$ = mk_node("ForInType", 2, $3, $5); }
1109 ;
1110
1111 for_in_type_suffix
1112 : ty_bare_fn
1113 | trait_ref
1114 | ty_closure
1115 ;
1116
1117 maybe_mut
1118 : MUT              { $$ = mk_atom("MutMutable"); }
1119 | %prec MUT %empty { $$ = mk_atom("MutImmutable"); }
1120 ;
1121
1122 maybe_mut_or_const
1123 : MUT    { $$ = mk_atom("MutMutable"); }
1124 | CONST  { $$ = mk_atom("MutImmutable"); }
1125 | %empty { $$ = mk_atom("MutImmutable"); }
1126 ;
1127
1128 ty_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
1139 ty_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
1144 maybe_ty_sums
1145 : ty_sums
1146 | ty_sums ','
1147 | %empty { $$ = mk_none(); }
1148 ;
1149
1150 ty_sums
1151 : ty_sum             { $$ = mk_node("TySums", 1, $1); }
1152 | ty_sums ',' ty_sum { $$ = ext_node($1, 1, $3); }
1153 ;
1154
1155 ty_sum
1156 : ty_sum_elt            { $$ = mk_node("TySum", 1, $1); }
1157 | ty_sum '+' ty_sum_elt { $$ = ext_node($1, 1, $3); }
1158 ;
1159
1160 ty_sum_elt
1161 : ty
1162 | lifetime
1163 ;
1164
1165 ty_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
1170 ty_prim_sum_elt
1171 : ty_prim
1172 | lifetime
1173 ;
1174
1175 maybe_ty_param_bounds
1176 : ':' ty_param_bounds { $$ = $2; }
1177 | %empty              { $$ = mk_none(); }
1178 ;
1179
1180 ty_param_bounds
1181 : boundseq
1182 | %empty { $$ = mk_none(); }
1183 ;
1184
1185 boundseq
1186 : polybound
1187 | boundseq '+' polybound { $$ = ext_node($1, 1, $3); }
1188 ;
1189
1190 polybound
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
1197 bindings
1198 : binding              { $$ = mk_node("Bindings", 1, $1); }
1199 | bindings ',' binding { $$ = ext_node($1, 1, $3); }
1200 ;
1201
1202 binding
1203 : ident '=' ty { mk_node("Binding", 2, $1, $3); }
1204 ;
1205
1206 ty_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
1211 maybe_bounds
1212 : %prec SHIFTPLUS
1213   ':' bounds             { $$ = $2; }
1214 | %prec SHIFTPLUS %empty { $$ = mk_none(); }
1215 ;
1216
1217 bounds
1218 : bound            { $$ = mk_node("bounds", 1, $1); }
1219 | bounds '+' bound { $$ = ext_node($1, 1, $3); }
1220 ;
1221
1222 bound
1223 : lifetime
1224 | trait_ref
1225 ;
1226
1227 maybe_ltbounds
1228 : %prec SHIFTPLUS
1229   ':' ltbounds       { $$ = $2; }
1230 | %empty             { $$ = mk_none(); }
1231 ;
1232
1233 ltbounds
1234 : lifetime              { $$ = mk_node("ltbounds", 1, $1); }
1235 | ltbounds '+' lifetime { $$ = ext_node($1, 1, $3); }
1236 ;
1237
1238 maybe_ty_default
1239 : '=' ty_sum { $$ = mk_node("TyDefault", 1, $2); }
1240 | %empty     { $$ = mk_none(); }
1241 ;
1242
1243 maybe_lifetimes
1244 : lifetimes
1245 | lifetimes ','
1246 | %empty { $$ = mk_none(); }
1247 ;
1248
1249 lifetimes
1250 : lifetime_and_bounds               { $$ = mk_node("Lifetimes", 1, $1); }
1251 | lifetimes ',' lifetime_and_bounds { $$ = ext_node($1, 1, $3); }
1252 ;
1253
1254 lifetime_and_bounds
1255 : LIFETIME maybe_ltbounds         { $$ = mk_node("lifetime", 2, mk_atom(yytext), $2); }
1256 | STATIC_LIFETIME                 { $$ = mk_atom("static_lifetime"); }
1257 ;
1258
1259 lifetime
1260 : LIFETIME         { $$ = mk_node("lifetime", 1, mk_atom(yytext)); }
1261 | STATIC_LIFETIME  { $$ = mk_atom("static_lifetime"); }
1262 ;
1263
1264 trait_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
1273 inner_attrs_and_block
1274 : '{' maybe_inner_attrs maybe_stmts '}'        { $$ = mk_node("ExprBlock", 2, $2, $3); }
1275 ;
1276
1277 block
1278 : '{' maybe_stmts '}'                          { $$ = mk_node("ExprBlock", 1, $2); }
1279 ;
1280
1281 maybe_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
1312 stmts
1313 : stmt           { $$ = mk_node("stmts", 1, $1); }
1314 | stmts stmt     { $$ = ext_node($1, 1, $2); }
1315 ;
1316
1317 stmt
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
1330 maybe_exprs
1331 : exprs
1332 | exprs ','
1333 | %empty { $$ = mk_none(); }
1334 ;
1335
1336 maybe_expr
1337 : expr
1338 | %empty { $$ = mk_none(); }
1339 ;
1340
1341 exprs
1342 : expr                                                        { $$ = mk_node("exprs", 1, $1); }
1343 | exprs ',' expr                                              { $$ = ext_node($1, 1, $3); }
1344 ;
1345
1346 path_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.
1357 path_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
1366 macro_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
1371 nonblock_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
1433 expr
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
1497 expr_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
1560 nonblock_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
1570 nonblock_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
1580 expr_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
1602 maybe_qpath_params
1603 : MOD_SEP generic_args { $$ = $2; }
1604 | %empty               { $$ = mk_none(); }
1605 ;
1606
1607 maybe_as_trait_ref
1608 : AS trait_ref { $$ = $2; }
1609 | %empty       { $$ = mk_none(); }
1610 ;
1611
1612 lambda_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
1623 lambda_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
1632 lambda_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
1643 lambda_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
1652 vec_expr
1653 : maybe_exprs
1654 | exprs ';' expr { $$ = mk_node("VecRepeat", 2, $1, $3); }
1655 ;
1656
1657 struct_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
1664 maybe_field_inits
1665 : field_inits
1666 | field_inits ','
1667 | %empty { $$ = mk_none(); }
1668 ;
1669
1670 field_inits
1671 : field_init                 { $$ = mk_node("FieldInits", 1, $1); }
1672 | field_inits ',' field_init { $$ = ext_node($1, 1, $3); }
1673 ;
1674
1675 field_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
1681 default_field_init
1682 : DOTDOT expr   { $$ = mk_node("DefaultFieldInit", 1, $2); }
1683 ;
1684
1685 block_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
1697 full_block_expr
1698 : block_expr
1699 | block_expr_dot
1700 ;
1701
1702 block_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
1713 expr_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
1720 match_clauses
1721 : match_clause               { $$ = mk_node("Arms", 1, $1); }
1722 | match_clauses match_clause { $$ = ext_node($1, 1, $2); }
1723 ;
1724
1725 match_clause
1726 : nonblock_match_clause ','
1727 | block_match_clause
1728 | block_match_clause ','
1729 ;
1730
1731 nonblock_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
1736 block_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
1741 maybe_guard
1742 : IF expr_nostruct           { $$ = $2; }
1743 | %empty                     { $$ = mk_none(); }
1744 ;
1745
1746 expr_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
1751 expr_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
1756 block_or_if
1757 : block
1758 | expr_if
1759 | expr_if_let
1760 ;
1761
1762 expr_while
1763 : maybe_label WHILE expr_nostruct block               { $$ = mk_node("ExprWhile", 3, $1, $3, $4); }
1764 ;
1765
1766 expr_while_let
1767 : maybe_label WHILE LET pat '=' expr_nostruct block   { $$ = mk_node("ExprWhileLet", 4, $1, $4, $6, $7); }
1768 ;
1769
1770 expr_loop
1771 : maybe_label LOOP block                              { $$ = mk_node("ExprLoop", 2, $1, $3); }
1772 ;
1773
1774 expr_for
1775 : maybe_label FOR pat IN expr_nostruct block          { $$ = mk_node("ExprForLoop", 4, $1, $3, $5, $6); }
1776 ;
1777
1778 maybe_label
1779 : lifetime ':'
1780 | %empty { $$ = mk_none(); }
1781 ;
1782
1783 let
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
1791 lit
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
1801 str
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
1808 maybe_ident
1809 : %empty { $$ = mk_none(); }
1810 | ident
1811 ;
1812
1813 ident
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
1821 unpaired_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
1938 token_trees
1939 : %empty                     { $$ = mk_node("TokenTrees", 0); }
1940 | token_trees token_tree     { $$ = ext_node($1, 1, $2); }
1941 ;
1942
1943 token_tree
1944 : delimited_token_trees
1945 | unpaired_token         { $$ = mk_node("TTTok", 1, $1); }
1946 ;
1947
1948 delimited_token_trees
1949 : parens_delimited_token_trees
1950 | braces_delimited_token_trees
1951 | brackets_delimited_token_trees
1952 ;
1953
1954 parens_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
1964 braces_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
1974 brackets_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 ;