fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #66089 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum4560ea788cb

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