src/grammar/parser-lalr.y

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