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