diff --git a/src/doc/grammar.md b/src/doc/grammar.md
index ee9135b6578f6..4501d74073e90 100644
--- a/src/doc/grammar.md
+++ b/src/doc/grammar.md
@@ -1,812 +1,7 @@
% Grammar
-# Introduction
+The Rust grammar may now be found in the [reference]. Additionally, the [grammar
+working group] is working on producing a testable grammar.
-This document is the primary reference for the Rust programming language grammar. It
-provides only one kind of material:
-
- - Chapters that formally define the language grammar.
-
-This document does not serve as an introduction to the language. Background
-familiarity with the language is assumed. A separate [guide] is available to
-help acquire such background.
-
-This document also does not serve as a reference to the [standard] library
-included in the language distribution. Those libraries are documented
-separately by extracting documentation attributes from their source code. Many
-of the features that one might expect to be language features are library
-features in Rust, so what you're looking for may be there, not here.
-
-[guide]: guide.html
-[standard]: std/index.html
-
-# Notation
-
-Rust's grammar is defined over Unicode codepoints, each conventionally denoted
-`U+XXXX`, for 4 or more hexadecimal digits `X`. _Most_ of Rust's grammar is
-confined to the ASCII range of Unicode, and is described in this document by a
-dialect of Extended Backus-Naur Form (EBNF), specifically a dialect of EBNF
-supported by common automated LL(k) parsing tools such as `llgen`, rather than
-the dialect given in ISO 14977. The dialect can be defined self-referentially
-as follows:
-
-```antlr
-grammar : rule + ;
-rule : nonterminal ':' productionrule ';' ;
-productionrule : production [ '|' production ] * ;
-production : term * ;
-term : element repeats ;
-element : LITERAL | IDENTIFIER | '[' productionrule ']' ;
-repeats : [ '*' | '+' ] NUMBER ? | NUMBER ? | '?' ;
-```
-
-Where:
-
-- Whitespace in the grammar is ignored.
-- Square brackets are used to group rules.
-- `LITERAL` is a single printable ASCII character, or an escaped hexadecimal
- ASCII code of the form `\xQQ`, in single quotes, denoting the corresponding
- Unicode codepoint `U+00QQ`.
-- `IDENTIFIER` is a nonempty string of ASCII letters and underscores.
-- The `repeat` forms apply to the adjacent `element`, and are as follows:
- - `?` means zero or one repetition
- - `*` means zero or more repetitions
- - `+` means one or more repetitions
- - NUMBER trailing a repeat symbol gives a maximum repetition count
- - NUMBER on its own gives an exact repetition count
-
-This EBNF dialect should hopefully be familiar to many readers.
-
-## Unicode productions
-
-A few productions in Rust's grammar permit Unicode codepoints outside the ASCII
-range. We define these productions in terms of character properties specified
-in the Unicode standard, rather than in terms of ASCII-range codepoints. The
-section [Special Unicode Productions](#special-unicode-productions) lists these
-productions.
-
-## String table productions
-
-Some rules in the grammar — notably [unary
-operators](#unary-operator-expressions), [binary
-operators](#binary-operator-expressions), and [keywords](#keywords) — are
-given in a simplified form: as a listing of a table of unquoted, printable
-whitespace-separated strings. These cases form a subset of the rules regarding
-the [token](#tokens) rule, and are assumed to be the result of a
-lexical-analysis phase feeding the parser, driven by a DFA, operating over the
-disjunction of all such string table entries.
-
-When such a string enclosed in double-quotes (`"`) occurs inside the grammar,
-it is an implicit reference to a single member of such a string table
-production. See [tokens](#tokens) for more information.
-
-# Lexical structure
-
-## Input format
-
-Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8.
-Most Rust grammar rules are defined in terms of printable ASCII-range
-codepoints, but a small number are defined in terms of Unicode properties or
-explicit codepoint lists. [^inputformat]
-
-[^inputformat]: Substitute definitions for the special Unicode productions are
- provided to the grammar verifier, restricted to ASCII range, when verifying the
- grammar in this document.
-
-## Special Unicode Productions
-
-The following productions in the Rust grammar are defined in terms of Unicode
-properties: `ident`, `non_null`, `non_eol`, `non_single_quote` and
-`non_double_quote`.
-
-### Identifiers
-
-The `ident` production is any nonempty Unicode string of
-the following form:
-
-- The first character is in one of the following ranges `U+0041` to `U+005A`
-("A" to "Z"), `U+0061` to `U+007A` ("a" to "z"), or `U+005F` ("\_").
-- The remaining characters are in the range `U+0030` to `U+0039` ("0" to "9"),
-or any of the prior valid initial characters.
-
-as long as the identifier does _not_ occur in the set of [keywords](#keywords).
-
-### Delimiter-restricted productions
-
-Some productions are defined by exclusion of particular Unicode characters:
-
-- `non_null` is any single Unicode character aside from `U+0000` (null)
-- `non_eol` is any single Unicode character aside from `U+000A` (`'\n'`)
-- `non_single_quote` is any single Unicode character aside from `U+0027` (`'`)
-- `non_double_quote` is any single Unicode character aside from `U+0022` (`"`)
-
-## Comments
-
-```antlr
-comment : block_comment | line_comment ;
-block_comment : "/*" block_comment_body * "*/" ;
-block_comment_body : [block_comment | character] * ;
-line_comment : "//" non_eol * ;
-```
-
-**FIXME:** add doc grammar?
-
-## Whitespace
-
-```antlr
-whitespace_char : '\x20' | '\x09' | '\x0a' | '\x0d' ;
-whitespace : [ whitespace_char | comment ] + ;
-```
-
-## Tokens
-
-```antlr
-simple_token : keyword | unop | binop ;
-token : simple_token | ident | literal | symbol | whitespace token ;
-```
-
-### Keywords
-
-
-
-| | | | | |
-|----------|----------|----------|----------|----------|
-| _ | abstract | alignof | as | become |
-| box | break | const | continue | crate |
-| do | else | enum | extern | false |
-| final | fn | for | if | impl |
-| in | let | loop | macro | match |
-| mod | move | mut | offsetof | override |
-| priv | proc | pub | pure | ref |
-| return | Self | self | sizeof | static |
-| struct | super | trait | true | type |
-| typeof | unsafe | unsized | use | virtual |
-| where | while | yield | | |
-
-
-Each of these keywords has special meaning in its grammar, and all of them are
-excluded from the `ident` rule.
-
-Not all of these keywords are used by the language. Some of them were used
-before Rust 1.0, and were left reserved once their implementations were
-removed. Some of them were reserved before 1.0 to make space for possible
-future features.
-
-### Literals
-
-```antlr
-lit_suffix : ident;
-literal : [ string_lit | char_lit | byte_string_lit | byte_lit | num_lit | bool_lit ] lit_suffix ?;
-```
-
-The optional `lit_suffix` production is only used for certain numeric literals,
-but is reserved for future extension. That is, the above gives the lexical
-grammar, but a Rust parser will reject everything but the 12 special cases
-mentioned in [Number literals](reference/tokens.html#number-literals) in the
-reference.
-
-#### Character and string literals
-
-```antlr
-char_lit : '\x27' char_body '\x27' ;
-string_lit : '"' string_body * '"' | 'r' raw_string ;
-
-char_body : non_single_quote
- | '\x5c' [ '\x27' | common_escape | unicode_escape ] ;
-
-string_body : non_double_quote
- | '\x5c' [ '\x22' | common_escape | unicode_escape ] ;
-raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
-
-common_escape : '\x5c'
- | 'n' | 'r' | 't' | '0'
- | 'x' hex_digit 2
-unicode_escape : 'u' '{' hex_digit+ 6 '}';
-
-hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
- | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
- | dec_digit ;
-oct_digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
-dec_digit : '0' | nonzero_dec ;
-nonzero_dec: '1' | '2' | '3' | '4'
- | '5' | '6' | '7' | '8' | '9' ;
-```
-
-#### Byte and byte string literals
-
-```antlr
-byte_lit : "b\x27" byte_body '\x27' ;
-byte_string_lit : "b\x22" string_body * '\x22' | "br" raw_byte_string ;
-
-byte_body : ascii_non_single_quote
- | '\x5c' [ '\x27' | common_escape ] ;
-
-byte_string_body : ascii_non_double_quote
- | '\x5c' [ '\x22' | common_escape ] ;
-raw_byte_string : '"' raw_byte_string_body '"' | '#' raw_byte_string '#' ;
-
-```
-
-#### Number literals
-
-```antlr
-num_lit : nonzero_dec [ dec_digit | '_' ] * float_suffix ?
- | '0' [ [ dec_digit | '_' ] * float_suffix ?
- | 'b' [ '1' | '0' | '_' ] +
- | 'o' [ oct_digit | '_' ] +
- | 'x' [ hex_digit | '_' ] + ] ;
-
-float_suffix : [ exponent | '.' dec_lit exponent ? ] ? ;
-
-exponent : ['E' | 'e'] ['-' | '+' ] ? dec_lit ;
-dec_lit : [ dec_digit | '_' ] + ;
-```
-
-#### Boolean literals
-
-```antlr
-bool_lit : [ "true" | "false" ] ;
-```
-
-The two values of the boolean type are written `true` and `false`.
-
-### Symbols
-
-```antlr
-symbol : "::" | "->"
- | '#' | '[' | ']' | '(' | ')' | '{' | '}'
- | ',' | ';' ;
-```
-
-Symbols are a general class of printable [tokens](#tokens) that play structural
-roles in a variety of grammar productions. They are cataloged here for
-completeness as the set of remaining miscellaneous printable tokens that do not
-otherwise appear as [unary operators](#unary-operator-expressions), [binary
-operators](#binary-operator-expressions), or [keywords](#keywords).
-
-## Paths
-
-```antlr
-expr_path : [ "::" ] ident [ "::" expr_path_tail ] + ;
-expr_path_tail : '<' type_expr [ ',' type_expr ] + '>'
- | expr_path ;
-
-type_path : ident [ type_path_tail ] + ;
-type_path_tail : '<' type_expr [ ',' type_expr ] + '>'
- | "::" type_path ;
-```
-
-# Syntax extensions
-
-## Macros
-
-```antlr
-expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';'
- | "macro_rules" '!' ident '{' macro_rule * '}' ;
-macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
-matcher : '(' matcher * ')' | '[' matcher * ']'
- | '{' matcher * '}' | '$' ident ':' ident
- | '$' '(' matcher * ')' sep_token? [ '*' | '+' ]
- | non_special_token ;
-transcriber : '(' transcriber * ')' | '[' transcriber * ']'
- | '{' transcriber * '}' | '$' ident
- | '$' '(' transcriber * ')' sep_token? [ '*' | '+' ]
- | non_special_token ;
-```
-
-# Crates and source files
-
-**FIXME:** grammar? What production covers #![crate_id = "foo"] ?
-
-# Items and attributes
-
-**FIXME:** grammar?
-
-## Items
-
-```antlr
-item : vis ? mod_item | fn_item | type_item | struct_item | enum_item
- | const_item | static_item | trait_item | impl_item | extern_block_item ;
-```
-
-### Type Parameters
-
-**FIXME:** grammar?
-
-### Modules
-
-```antlr
-mod_item : "mod" ident ( ';' | '{' mod '}' );
-mod : [ view_item | item ] * ;
-```
-
-#### View items
-
-```antlr
-view_item : extern_crate_decl | use_decl ';' ;
-```
-
-##### Extern crate declarations
-
-```antlr
-extern_crate_decl : "extern" "crate" crate_name
-crate_name: ident | ( ident "as" ident )
-```
-
-##### Use declarations
-
-```antlr
-use_decl : vis ? "use" [ path "as" ident
- | path_glob ] ;
-
-path_glob : ident [ "::" [ path_glob
- | '*' ] ] ?
- | '{' path_item [ ',' path_item ] * '}' ;
-
-path_item : ident | "self" ;
-```
-
-### Functions
-
-**FIXME:** grammar?
-
-#### Generic functions
-
-**FIXME:** grammar?
-
-#### Unsafety
-
-**FIXME:** grammar?
-
-##### Unsafe functions
-
-**FIXME:** grammar?
-
-##### Unsafe blocks
-
-**FIXME:** grammar?
-
-#### Diverging functions
-
-**FIXME:** grammar?
-
-### Type definitions
-
-**FIXME:** grammar?
-
-### Structures
-
-**FIXME:** grammar?
-
-### Enumerations
-
-**FIXME:** grammar?
-
-### Constant items
-
-```antlr
-const_item : "const" ident ':' type '=' expr ';' ;
-```
-
-### Static items
-
-```antlr
-static_item : "static" ident ':' type '=' expr ';' ;
-```
-
-#### Mutable statics
-
-**FIXME:** grammar?
-
-### Traits
-
-**FIXME:** grammar?
-
-### Implementations
-
-**FIXME:** grammar?
-
-### External blocks
-
-```antlr
-extern_block_item : "extern" '{' extern_block '}' ;
-extern_block : [ foreign_fn ] * ;
-```
-
-## Visibility and Privacy
-
-```antlr
-vis : "pub" ;
-```
-### Re-exporting and Visibility
-
-See [Use declarations](#use-declarations).
-
-## Attributes
-
-```antlr
-attribute : '#' '!' ? '[' meta_item ']' ;
-meta_item : ident [ '=' literal
- | '(' meta_seq ')' ] ? ;
-meta_seq : meta_item [ ',' meta_seq ] ? ;
-```
-
-# Statements and expressions
-
-## Statements
-
-```antlr
-stmt : decl_stmt | expr_stmt | ';' ;
-```
-
-### Declaration statements
-
-```antlr
-decl_stmt : item | let_decl ;
-```
-
-#### Item declarations
-
-See [Items](#items).
-
-#### Variable declarations
-
-```antlr
-let_decl : "let" pat [':' type ] ? [ init ] ? ';' ;
-init : [ '=' ] expr ;
-```
-
-### Expression statements
-
-```antlr
-expr_stmt : expr ';' ;
-```
-
-## Expressions
-
-```antlr
-expr : literal | path | tuple_expr | unit_expr | struct_expr
- | block_expr | method_call_expr | field_expr | array_expr
- | idx_expr | range_expr | unop_expr | binop_expr
- | paren_expr | call_expr | lambda_expr | while_expr
- | loop_expr | break_expr | continue_expr | for_expr
- | if_expr | match_expr | if_let_expr | while_let_expr
- | return_expr ;
-```
-
-#### Lvalues, rvalues and temporaries
-
-**FIXME:** grammar?
-
-#### Moved and copied types
-
-**FIXME:** Do we want to capture this in the grammar as different productions?
-
-### Literal expressions
-
-See [Literals](#literals).
-
-### Path expressions
-
-See [Paths](#paths).
-
-### Tuple expressions
-
-```antlr
-tuple_expr : '(' [ expr [ ',' expr ] * | expr ',' ] ? ')' ;
-```
-
-### Unit expressions
-
-```antlr
-unit_expr : "()" ;
-```
-
-### Structure expressions
-
-```antlr
-struct_expr_field_init : ident | ident ':' expr ;
-struct_expr : expr_path '{' struct_expr_field_init
- [ ',' struct_expr_field_init ] *
- [ ".." expr ] '}' |
- expr_path '(' expr
- [ ',' expr ] * ')' |
- expr_path ;
-```
-
-### Block expressions
-
-```antlr
-block_expr : '{' [ stmt | item ] *
- [ expr ] '}' ;
-```
-
-### Method-call expressions
-
-```antlr
-method_call_expr : expr '.' ident paren_expr_list ;
-```
-
-### Field expressions
-
-```antlr
-field_expr : expr '.' ident ;
-```
-
-### Array expressions
-
-```antlr
-array_expr : '[' "mut" ? array_elems? ']' ;
-
-array_elems : [expr [',' expr]*] | [expr ';' expr] ;
-```
-
-### Index expressions
-
-```antlr
-idx_expr : expr '[' expr ']' ;
-```
-
-### Range expressions
-
-```antlr
-range_expr : expr ".." expr |
- expr ".." |
- ".." expr |
- ".." ;
-```
-
-### Unary operator expressions
-
-```antlr
-unop_expr : unop expr ;
-unop : '-' | '*' | '!' ;
-```
-
-### Binary operator expressions
-
-```antlr
-binop_expr : expr binop expr | type_cast_expr
- | assignment_expr | compound_assignment_expr ;
-binop : arith_op | bitwise_op | lazy_bool_op | comp_op
-```
-
-#### Arithmetic operators
-
-```antlr
-arith_op : '+' | '-' | '*' | '/' | '%' ;
-```
-
-#### Bitwise operators
-
-```antlr
-bitwise_op : '&' | '|' | '^' | "<<" | ">>" ;
-```
-
-#### Lazy boolean operators
-
-```antlr
-lazy_bool_op : "&&" | "||" ;
-```
-
-#### Comparison operators
-
-```antlr
-comp_op : "==" | "!=" | '<' | '>' | "<=" | ">=" ;
-```
-
-#### Type cast expressions
-
-```antlr
-type_cast_expr : value "as" type ;
-```
-
-#### Assignment expressions
-
-```antlr
-assignment_expr : expr '=' expr ;
-```
-
-#### Compound assignment expressions
-
-```antlr
-compound_assignment_expr : expr [ arith_op | bitwise_op ] '=' expr ;
-```
-
-### Grouped expressions
-
-```antlr
-paren_expr : '(' expr ')' ;
-```
-
-### Call expressions
-
-```antlr
-expr_list : [ expr [ ',' expr ]* ] ? ;
-paren_expr_list : '(' expr_list ')' ;
-call_expr : expr paren_expr_list ;
-```
-
-### Lambda expressions
-
-```antlr
-ident_list : [ ident [ ',' ident ]* ] ? ;
-lambda_expr : '|' ident_list '|' expr ;
-```
-
-### While loops
-
-```antlr
-while_expr : [ lifetime ':' ] ? "while" no_struct_literal_expr '{' block '}' ;
-```
-
-### Infinite loops
-
-```antlr
-loop_expr : [ lifetime ':' ] ? "loop" '{' block '}';
-```
-
-### Break expressions
-
-```antlr
-break_expr : "break" [ lifetime ] ?;
-```
-
-### Continue expressions
-
-```antlr
-continue_expr : "continue" [ lifetime ] ?;
-```
-
-### For expressions
-
-```antlr
-for_expr : [ lifetime ':' ] ? "for" pat "in" no_struct_literal_expr '{' block '}' ;
-```
-
-### If expressions
-
-```antlr
-if_expr : "if" no_struct_literal_expr '{' block '}'
- else_tail ? ;
-
-else_tail : "else" [ if_expr | if_let_expr
- | '{' block '}' ] ;
-```
-
-### Match expressions
-
-```antlr
-match_expr : "match" no_struct_literal_expr '{' match_arm * '}' ;
-
-match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
-
-match_pat : pat [ '|' pat ] * [ "if" expr ] ? ;
-```
-
-### If let expressions
-
-```antlr
-if_let_expr : "if" "let" pat '=' expr '{' block '}'
- else_tail ? ;
-```
-
-### While let loops
-
-```antlr
-while_let_expr : [ lifetime ':' ] ? "while" "let" pat '=' expr '{' block '}' ;
-```
-
-### Return expressions
-
-```antlr
-return_expr : "return" expr ? ;
-```
-
-# Type system
-
-**FIXME:** is this entire chapter relevant here? Or should it all have been covered by some production already?
-
-## Types
-
-### Primitive types
-
-**FIXME:** grammar?
-
-#### Machine types
-
-**FIXME:** grammar?
-
-#### Machine-dependent integer types
-
-**FIXME:** grammar?
-
-### Textual types
-
-**FIXME:** grammar?
-
-### Tuple types
-
-**FIXME:** grammar?
-
-### Array, and Slice types
-
-**FIXME:** grammar?
-
-### Structure types
-
-**FIXME:** grammar?
-
-### Enumerated types
-
-**FIXME:** grammar?
-
-### Pointer types
-
-**FIXME:** grammar?
-
-### Function types
-
-**FIXME:** grammar?
-
-### Closure types
-
-```antlr
-closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
- [ ':' bound-list ] [ '->' type ]
-lifetime-list := lifetime | lifetime ',' lifetime-list
-arg-list := ident ':' type | ident ':' type ',' arg-list
-```
-
-### Never type
-An empty type
-
-```antlr
-never_type : "!" ;
-```
-
-### Object types
-
-**FIXME:** grammar?
-
-### Type parameters
-
-**FIXME:** grammar?
-
-### Type parameter bounds
-
-```antlr
-bound-list := bound | bound '+' bound-list '+' ?
-bound := ty_bound | lt_bound
-lt_bound := lifetime
-ty_bound := ty_bound_noparen | (ty_bound_noparen)
-ty_bound_noparen := [?] [ for ] simple_path
-```
-
-### Self types
-
-**FIXME:** grammar?
-
-## Type kinds
-
-**FIXME:** this is probably not relevant to the grammar...
-
-# Memory and concurrency models
-
-**FIXME:** is this entire chapter relevant here? Or should it all have been covered by some production already?
-
-## Memory model
-
-### Memory allocation and lifetime
-
-### Memory ownership
-
-### Variables
-
-### Boxes
-
-## Threads
-
-### Communication between threads
-
-### Thread lifecycle
+[reference]: https://doc.rust-lang.org/reference/
+[grammar working group]: https://github.com/rust-lang/wg-grammar
diff --git a/src/grammar/.gitignore b/src/grammar/.gitignore
deleted file mode 100644
index 3e4498759434f..0000000000000
--- a/src/grammar/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.class
-*.java
-*.tokens
diff --git a/src/grammar/lexer.l b/src/grammar/lexer.l
deleted file mode 100644
index 1feb781b2b39f..0000000000000
--- a/src/grammar/lexer.l
+++ /dev/null
@@ -1,350 +0,0 @@
-%{
-#include
-#include
-
-static int num_hashes;
-static int end_hashes;
-static int saw_non_hash;
-
-%}
-
-%option stack
-%option yylineno
-
-%x str
-%x rawstr
-%x rawstr_esc_begin
-%x rawstr_esc_body
-%x rawstr_esc_end
-%x byte
-%x bytestr
-%x rawbytestr
-%x rawbytestr_nohash
-%x pound
-%x shebang_or_attr
-%x ltorchar
-%x linecomment
-%x doc_line
-%x blockcomment
-%x doc_block
-%x suffix
-
-ident [a-zA-Z\x80-\xff_][a-zA-Z0-9\x80-\xff_]*
-
-%%
-
-{ident} { BEGIN(INITIAL); }
-(.|\n) { yyless(0); BEGIN(INITIAL); }
-
-[ \n\t\r] { }
-
-\xef\xbb\xbf {
- // UTF-8 byte order mark (BOM), ignore if in line 1, error otherwise
- if (yyget_lineno() != 1) {
- return -1;
- }
-}
-
-\/\/(\/|\!) { BEGIN(doc_line); yymore(); }
-\n { BEGIN(INITIAL);
- yyleng--;
- yytext[yyleng] = 0;
- return ((yytext[2] == '!') ? INNER_DOC_COMMENT : OUTER_DOC_COMMENT);
- }
-[^\n]* { yymore(); }
-
-\/\/|\/\/\/\/ { BEGIN(linecomment); }
-\n { BEGIN(INITIAL); }
-[^\n]* { }
-
-\/\*(\*|\!)[^*] { yy_push_state(INITIAL); yy_push_state(doc_block); yymore(); }
-\/\* { yy_push_state(doc_block); yymore(); }
-\*\/ {
- yy_pop_state();
- if (yy_top_state() == doc_block) {
- yymore();
- } else {
- return ((yytext[2] == '!') ? INNER_DOC_COMMENT : OUTER_DOC_COMMENT);
- }
-}
-(.|\n) { yymore(); }
-
-\/\* { yy_push_state(blockcomment); }
-\/\* { yy_push_state(blockcomment); }
-\*\/ { yy_pop_state(); }
-(.|\n) { }
-
-_ { return UNDERSCORE; }
-abstract { return ABSTRACT; }
-alignof { return ALIGNOF; }
-as { return AS; }
-become { return BECOME; }
-box { return BOX; }
-break { return BREAK; }
-catch { return CATCH; }
-const { return CONST; }
-continue { return CONTINUE; }
-crate { return CRATE; }
-default { return DEFAULT; }
-do { return DO; }
-else { return ELSE; }
-enum { return ENUM; }
-extern { return EXTERN; }
-false { return FALSE; }
-final { return FINAL; }
-fn { return FN; }
-for { return FOR; }
-if { return IF; }
-impl { return IMPL; }
-in { return IN; }
-let { return LET; }
-loop { return LOOP; }
-macro { return MACRO; }
-match { return MATCH; }
-mod { return MOD; }
-move { return MOVE; }
-mut { return MUT; }
-offsetof { return OFFSETOF; }
-override { return OVERRIDE; }
-priv { return PRIV; }
-proc { return PROC; }
-pure { return PURE; }
-pub { return PUB; }
-ref { return REF; }
-return { return RETURN; }
-self { return SELF; }
-sizeof { return SIZEOF; }
-static { return STATIC; }
-struct { return STRUCT; }
-super { return SUPER; }
-trait { return TRAIT; }
-true { return TRUE; }
-type { return TYPE; }
-typeof { return TYPEOF; }
-union { return UNION; }
-unsafe { return UNSAFE; }
-unsized { return UNSIZED; }
-use { return USE; }
-virtual { return VIRTUAL; }
-where { return WHERE; }
-while { return WHILE; }
-yield { return YIELD; }
-
-{ident} { return IDENT; }
-
-0x[0-9a-fA-F_]+ { BEGIN(suffix); return LIT_INTEGER; }
-0o[0-7_]+ { BEGIN(suffix); return LIT_INTEGER; }
-0b[01_]+ { BEGIN(suffix); return LIT_INTEGER; }
-[0-9][0-9_]* { BEGIN(suffix); return LIT_INTEGER; }
-[0-9][0-9_]*\.(\.|[a-zA-Z]) { yyless(yyleng - 2); BEGIN(suffix); return LIT_INTEGER; }
-
-[0-9][0-9_]*\.[0-9_]*([eE][-\+]?[0-9_]+)? { BEGIN(suffix); return LIT_FLOAT; }
-[0-9][0-9_]*(\.[0-9_]*)?[eE][-\+]?[0-9_]+ { BEGIN(suffix); return LIT_FLOAT; }
-
-; { return ';'; }
-, { return ','; }
-\.\.\. { return DOTDOTDOT; }
-\.\. { return DOTDOT; }
-\. { return '.'; }
-\( { return '('; }
-\) { return ')'; }
-\{ { return '{'; }
-\} { return '}'; }
-\[ { return '['; }
-\] { return ']'; }
-@ { return '@'; }
-# { BEGIN(pound); yymore(); }
-\! { BEGIN(shebang_or_attr); yymore(); }
-\[ {
- BEGIN(INITIAL);
- yyless(2);
- return SHEBANG;
-}
-[^\[\n]*\n {
- // Since the \n was eaten as part of the token, yylineno will have
- // been incremented to the value 2 if the shebang was on the first
- // line. This yyless undoes that, setting yylineno back to 1.
- yyless(yyleng - 1);
- if (yyget_lineno() == 1) {
- BEGIN(INITIAL);
- return SHEBANG_LINE;
- } else {
- BEGIN(INITIAL);
- yyless(2);
- return SHEBANG;
- }
-}
-. { BEGIN(INITIAL); yyless(1); return '#'; }
-
-\~ { return '~'; }
-:: { return MOD_SEP; }
-: { return ':'; }
-\$ { return '$'; }
-\? { return '?'; }
-
-== { return EQEQ; }
-=> { return FAT_ARROW; }
-= { return '='; }
-\!= { return NE; }
-\! { return '!'; }
-\<= { return LE; }
-\<\< { return SHL; }
-\<\<= { return SHLEQ; }
-\< { return '<'; }
-\>= { return GE; }
-\>\> { return SHR; }
-\>\>= { return SHREQ; }
-\> { return '>'; }
-
-\x27 { BEGIN(ltorchar); yymore(); }
-static { BEGIN(INITIAL); return STATIC_LIFETIME; }
-{ident} { BEGIN(INITIAL); return LIFETIME; }
-\\[nrt\\\x27\x220]\x27 { BEGIN(suffix); return LIT_CHAR; }
-\\x[0-9a-fA-F]{2}\x27 { BEGIN(suffix); return LIT_CHAR; }
-\\u\{([0-9a-fA-F]_*){1,6}\}\x27 { BEGIN(suffix); return LIT_CHAR; }
-.\x27 { BEGIN(suffix); return LIT_CHAR; }
-[\x80-\xff]{2,4}\x27 { BEGIN(suffix); return LIT_CHAR; }
-<> { BEGIN(INITIAL); return -1; }
-
-b\x22 { BEGIN(bytestr); yymore(); }
-\x22 { BEGIN(suffix); return LIT_BYTE_STR; }
-
-<> { return -1; }
-\\[n\nrt\\\x27\x220] { yymore(); }
-\\x[0-9a-fA-F]{2} { yymore(); }
-\\u\{([0-9a-fA-F]_*){1,6}\} { yymore(); }
-\\[^n\nrt\\\x27\x220] { return -1; }
-(.|\n) { yymore(); }
-
-br\x22 { BEGIN(rawbytestr_nohash); yymore(); }
-\x22 { BEGIN(suffix); return LIT_BYTE_STR_RAW; }
-(.|\n) { yymore(); }
-<> { return -1; }
-
-br/# {
- BEGIN(rawbytestr);
- yymore();
- num_hashes = 0;
- saw_non_hash = 0;
- end_hashes = 0;
-}
-# {
- if (!saw_non_hash) {
- num_hashes++;
- } else if (end_hashes != 0) {
- end_hashes++;
- if (end_hashes == num_hashes) {
- BEGIN(INITIAL);
- return LIT_BYTE_STR_RAW;
- }
- }
- yymore();
-}
-\x22# {
- end_hashes = 1;
- if (end_hashes == num_hashes) {
- BEGIN(INITIAL);
- return LIT_BYTE_STR_RAW;
- }
- yymore();
-}
-(.|\n) {
- if (!saw_non_hash) {
- saw_non_hash = 1;
- }
- if (end_hashes != 0) {
- end_hashes = 0;
- }
- yymore();
-}
-<> { return -1; }
-
-b\x27 { BEGIN(byte); yymore(); }
-\\[nrt\\\x27\x220]\x27 { BEGIN(INITIAL); return LIT_BYTE; }
-\\x[0-9a-fA-F]{2}\x27 { BEGIN(INITIAL); return LIT_BYTE; }
-\\u([0-9a-fA-F]_*){4}\x27 { BEGIN(INITIAL); return LIT_BYTE; }
-\\U([0-9a-fA-F]_*){8}\x27 { BEGIN(INITIAL); return LIT_BYTE; }
-.\x27 { BEGIN(INITIAL); return LIT_BYTE; }
-<> { BEGIN(INITIAL); return -1; }
-
-r\x22 { BEGIN(rawstr); yymore(); }
-\x22 { BEGIN(suffix); return LIT_STR_RAW; }
-(.|\n) { yymore(); }
-<> { return -1; }
-
-r/# {
- BEGIN(rawstr_esc_begin);
- yymore();
- num_hashes = 0;
- saw_non_hash = 0;
- end_hashes = 0;
-}
-
-# {
- num_hashes++;
- yymore();
-}
-\x22 {
- BEGIN(rawstr_esc_body);
- yymore();
-}
-(.|\n) { return -1; }
-
-\x22/# {
- BEGIN(rawstr_esc_end);
- yymore();
- }
-(.|\n) {
- yymore();
- }
-
-# {
- end_hashes++;
- if (end_hashes == num_hashes) {
- BEGIN(INITIAL);
- return LIT_STR_RAW;
- }
- yymore();
- }
-[^#] {
- end_hashes = 0;
- BEGIN(rawstr_esc_body);
- yymore();
- }
-
-<> { return -1; }
-
-\x22 { BEGIN(str); yymore(); }
-\x22 { BEGIN(suffix); return LIT_STR; }
-
-<> { return -1; }
-\\[n\nr\rt\\\x27\x220] { yymore(); }
-\\x[0-9a-fA-F]{2} { yymore(); }
-\\u\{([0-9a-fA-F]_*){1,6}\} { yymore(); }
-\\[^n\nrt\\\x27\x220] { return -1; }
-(.|\n) { yymore(); }
-
-\<- { return LARROW; }
--\> { return RARROW; }
-- { return '-'; }
--= { return MINUSEQ; }
-&& { return ANDAND; }
-& { return '&'; }
-&= { return ANDEQ; }
-\|\| { return OROR; }
-\| { return '|'; }
-\|= { return OREQ; }
-\+ { return '+'; }
-\+= { return PLUSEQ; }
-\* { return '*'; }
-\*= { return STAREQ; }
-\/ { return '/'; }
-\/= { return SLASHEQ; }
-\^ { return '^'; }
-\^= { return CARETEQ; }
-% { return '%'; }
-%= { return PERCENTEQ; }
-
-<> { return 0; }
-
-%%
diff --git a/src/grammar/parser-lalr-main.c b/src/grammar/parser-lalr-main.c
deleted file mode 100644
index 6348190cc140b..0000000000000
--- a/src/grammar/parser-lalr-main.c
+++ /dev/null
@@ -1,193 +0,0 @@
-#include
-#include
-#include
-#include
-
-extern int yylex();
-extern int rsparse();
-
-#define PUSHBACK_LEN 4
-
-static char pushback[PUSHBACK_LEN];
-static int verbose;
-
-void print(const char* format, ...) {
- va_list args;
- va_start(args, format);
- if (verbose) {
- vprintf(format, args);
- }
- va_end(args);
-}
-
-// If there is a non-null char at the head of the pushback queue,
-// dequeue it and shift the rest of the queue forwards. Otherwise,
-// return the token from calling yylex.
-int rslex() {
- if (pushback[0] == '\0') {
- return yylex();
- } else {
- char c = pushback[0];
- memmove(pushback, pushback + 1, PUSHBACK_LEN - 1);
- pushback[PUSHBACK_LEN - 1] = '\0';
- return c;
- }
-}
-
-// Note: this does nothing if the pushback queue is full. As long as
-// there aren't more than PUSHBACK_LEN consecutive calls to push_back
-// in an action, this shouldn't be a problem.
-void push_back(char c) {
- for (int i = 0; i < PUSHBACK_LEN; ++i) {
- if (pushback[i] == '\0') {
- pushback[i] = c;
- break;
- }
- }
-}
-
-extern int rsdebug;
-
-struct node {
- struct node *next;
- struct node *prev;
- int own_string;
- char const *name;
- int n_elems;
- struct node *elems[];
-};
-
-struct node *nodes = NULL;
-int n_nodes;
-
-struct node *mk_node(char const *name, int n, ...) {
- va_list ap;
- int i = 0;
- unsigned sz = sizeof(struct node) + (n * sizeof(struct node *));
- struct node *nn, *nd = (struct node *)malloc(sz);
-
- print("# New %d-ary node: %s = %p\n", n, name, nd);
-
- nd->own_string = 0;
- nd->prev = NULL;
- nd->next = nodes;
- if (nodes) {
- nodes->prev = nd;
- }
- nodes = nd;
-
- nd->name = name;
- nd->n_elems = n;
-
- va_start(ap, n);
- while (i < n) {
- nn = va_arg(ap, struct node *);
- print("# arg[%d]: %p\n", i, nn);
- print("# (%s ...)\n", nn->name);
- nd->elems[i++] = nn;
- }
- va_end(ap);
- n_nodes++;
- return nd;
-}
-
-struct node *mk_atom(char *name) {
- struct node *nd = mk_node((char const *)strdup(name), 0);
- nd->own_string = 1;
- return nd;
-}
-
-struct node *mk_none() {
- return mk_atom("");
-}
-
-struct node *ext_node(struct node *nd, int n, ...) {
- va_list ap;
- int i = 0, c = nd->n_elems + n;
- unsigned sz = sizeof(struct node) + (c * sizeof(struct node *));
- struct node *nn;
-
- print("# Extending %d-ary node by %d nodes: %s = %p",
- nd->n_elems, c, nd->name, nd);
-
- if (nd->next) {
- nd->next->prev = nd->prev;
- }
- if (nd->prev) {
- nd->prev->next = nd->next;
- }
- nd = realloc(nd, sz);
- nd->prev = NULL;
- nd->next = nodes;
- nodes->prev = nd;
- nodes = nd;
-
- print(" ==> %p\n", nd);
-
- va_start(ap, n);
- while (i < n) {
- nn = va_arg(ap, struct node *);
- print("# arg[%d]: %p\n", i, nn);
- print("# (%s ...)\n", nn->name);
- nd->elems[nd->n_elems++] = nn;
- ++i;
- }
- va_end(ap);
- return nd;
-}
-
-int const indent_step = 4;
-
-void print_indent(int depth) {
- while (depth) {
- if (depth-- % indent_step == 0) {
- print("|");
- } else {
- print(" ");
- }
- }
-}
-
-void print_node(struct node *n, int depth) {
- int i = 0;
- print_indent(depth);
- if (n->n_elems == 0) {
- print("%s\n", n->name);
- } else {
- print("(%s\n", n->name);
- for (i = 0; i < n->n_elems; ++i) {
- print_node(n->elems[i], depth + indent_step);
- }
- print_indent(depth);
- print(")\n");
- }
-}
-
-int main(int argc, char **argv) {
- if (argc == 2 && strcmp(argv[1], "-v") == 0) {
- verbose = 1;
- } else {
- verbose = 0;
- }
- int ret = 0;
- struct node *tmp;
- memset(pushback, '\0', PUSHBACK_LEN);
- ret = rsparse();
- print("--- PARSE COMPLETE: ret:%d, n_nodes:%d ---\n", ret, n_nodes);
- if (nodes) {
- print_node(nodes, 0);
- }
- while (nodes) {
- tmp = nodes;
- nodes = tmp->next;
- if (tmp->own_string) {
- free((void*)tmp->name);
- }
- free(tmp);
- }
- return ret;
-}
-
-void rserror(char const *s) {
- fprintf(stderr, "%s\n", s);
-}
diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
deleted file mode 100644
index 5585c95a5a63a..0000000000000
--- a/src/grammar/parser-lalr.y
+++ /dev/null
@@ -1,1982 +0,0 @@
-%{
-#define YYERROR_VERBOSE
-#define YYSTYPE struct node *
-struct node;
-extern int yylex();
-extern void yyerror(char const *s);
-extern struct node *mk_node(char const *name, int n, ...);
-extern struct node *mk_atom(char *text);
-extern struct node *mk_none();
-extern struct node *ext_node(struct node *nd, int n, ...);
-extern void push_back(char c);
-extern char *yytext;
-%}
-%debug
-
-%token SHL
-%token SHR
-%token LE
-%token EQEQ
-%token NE
-%token GE
-%token ANDAND
-%token OROR
-%token SHLEQ
-%token SHREQ
-%token MINUSEQ
-%token ANDEQ
-%token OREQ
-%token PLUSEQ
-%token STAREQ
-%token SLASHEQ
-%token CARETEQ
-%token PERCENTEQ
-%token DOTDOT
-%token DOTDOTDOT
-%token MOD_SEP
-%token RARROW
-%token LARROW
-%token FAT_ARROW
-%token LIT_BYTE
-%token LIT_CHAR
-%token LIT_INTEGER
-%token LIT_FLOAT
-%token LIT_STR
-%token LIT_STR_RAW
-%token LIT_BYTE_STR
-%token LIT_BYTE_STR_RAW
-%token IDENT
-%token UNDERSCORE
-%token LIFETIME
-
-// keywords
-%token SELF
-%token STATIC
-%token ABSTRACT
-%token ALIGNOF
-%token AS
-%token BECOME
-%token BREAK
-%token CATCH
-%token CRATE
-%token DO
-%token ELSE
-%token ENUM
-%token EXTERN
-%token FALSE
-%token FINAL
-%token FN
-%token FOR
-%token IF
-%token IMPL
-%token IN
-%token LET
-%token LOOP
-%token MACRO
-%token MATCH
-%token MOD
-%token MOVE
-%token MUT
-%token OFFSETOF
-%token OVERRIDE
-%token PRIV
-%token PUB
-%token PURE
-%token REF
-%token RETURN
-%token SIZEOF
-%token STRUCT
-%token SUPER
-%token UNION
-%token UNSIZED
-%token TRUE
-%token TRAIT
-%token TYPE
-%token UNSAFE
-%token VIRTUAL
-%token YIELD
-%token DEFAULT
-%token USE
-%token WHILE
-%token CONTINUE
-%token PROC
-%token BOX
-%token CONST
-%token WHERE
-%token TYPEOF
-%token INNER_DOC_COMMENT
-%token OUTER_DOC_COMMENT
-
-%token SHEBANG
-%token SHEBANG_LINE
-%token STATIC_LIFETIME
-
- /*
- Quoting from the Bison manual:
-
- "Finally, the resolution of conflicts works by comparing the precedence
- of the rule being considered with that of the lookahead token. If the
- token's precedence is higher, the choice is to shift. If the rule's
- precedence is higher, the choice is to reduce. If they have equal
- precedence, the choice is made based on the associativity of that
- precedence level. The verbose output file made by ā-vā (see Invoking
- Bison) says how each conflict was resolved"
- */
-
-// We expect no shift/reduce or reduce/reduce conflicts in this grammar;
-// all potential ambiguities are scrutinized and eliminated manually.
-%expect 0
-
-// fake-precedence symbol to cause '|' bars in lambda context to parse
-// at low precedence, permit things like |x| foo = bar, where '=' is
-// otherwise lower-precedence than '|'. Also used for proc() to cause
-// things like proc() a + b to parse as proc() { a + b }.
-%precedence LAMBDA
-
-%precedence SELF
-
-// MUT should be lower precedence than IDENT so that in the pat rule,
-// "& MUT pat" has higher precedence than "binding_mode ident [@ pat]"
-%precedence MUT
-
-// IDENT needs to be lower than '{' so that 'foo {' is shifted when
-// trying to decide if we've got a struct-construction expr (esp. in
-// contexts like 'if foo { .')
-//
-// IDENT also needs to be lower precedence than '<' so that '<' in
-// 'foo:bar . <' is shifted (in a trait reference occurring in a
-// bounds list), parsing as foo:(bar) rather than (foo:bar).
-%precedence IDENT
- // Put the weak keywords that can be used as idents here as well
-%precedence CATCH
-%precedence DEFAULT
-%precedence UNION
-
-// A couple fake-precedence symbols to use in rules associated with +
-// and < in trailing type contexts. These come up when you have a type
-// in the RHS of operator-AS, such as "foo as bar". The "<" there
-// has to be shifted so the parser keeps trying to parse a type, even
-// though it might well consider reducing the type "bar" and then
-// going on to "<" as a subsequent binop. The "+" case is with
-// trailing type-bounds ("foo as bar:A+B"), for the same reason.
-%precedence SHIFTPLUS
-
-%precedence MOD_SEP
-%precedence RARROW ':'
-
-// In where clauses, "for" should have greater precedence when used as
-// a higher ranked constraint than when used as the beginning of a
-// for_in_type (which is a ty)
-%precedence FORTYPE
-%precedence FOR
-
-// Binops & unops, and their precedences
-%precedence '?'
-%precedence BOX
-%nonassoc DOTDOT
-
-// RETURN needs to be lower-precedence than tokens that start
-// prefix_exprs
-%precedence RETURN YIELD
-
-%right '=' SHLEQ SHREQ MINUSEQ ANDEQ OREQ PLUSEQ STAREQ SLASHEQ CARETEQ PERCENTEQ
-%right LARROW
-%left OROR
-%left ANDAND
-%left EQEQ NE
-%left '<' '>' LE GE
-%left '|'
-%left '^'
-%left '&'
-%left SHL SHR
-%left '+' '-'
-%precedence AS
-%left '*' '/' '%'
-%precedence '!'
-
-%precedence '{' '[' '(' '.'
-
-%precedence RANGE
-
-%start crate
-
-%%
-
-////////////////////////////////////////////////////////////////////////
-// Part 1: Items and attributes
-////////////////////////////////////////////////////////////////////////
-
-crate
-: maybe_shebang inner_attrs maybe_mod_items { mk_node("crate", 2, $2, $3); }
-| maybe_shebang maybe_mod_items { mk_node("crate", 1, $2); }
-;
-
-maybe_shebang
-: SHEBANG_LINE
-| %empty
-;
-
-maybe_inner_attrs
-: inner_attrs
-| %empty { $$ = mk_none(); }
-;
-
-inner_attrs
-: inner_attr { $$ = mk_node("InnerAttrs", 1, $1); }
-| inner_attrs inner_attr { $$ = ext_node($1, 1, $2); }
-;
-
-inner_attr
-: SHEBANG '[' meta_item ']' { $$ = mk_node("InnerAttr", 1, $3); }
-| INNER_DOC_COMMENT { $$ = mk_node("InnerAttr", 1, mk_node("doc-comment", 1, mk_atom(yytext))); }
-;
-
-maybe_outer_attrs
-: outer_attrs
-| %empty { $$ = mk_none(); }
-;
-
-outer_attrs
-: outer_attr { $$ = mk_node("OuterAttrs", 1, $1); }
-| outer_attrs outer_attr { $$ = ext_node($1, 1, $2); }
-;
-
-outer_attr
-: '#' '[' meta_item ']' { $$ = $3; }
-| OUTER_DOC_COMMENT { $$ = mk_node("doc-comment", 1, mk_atom(yytext)); }
-;
-
-meta_item
-: ident { $$ = mk_node("MetaWord", 1, $1); }
-| ident '=' lit { $$ = mk_node("MetaNameValue", 2, $1, $3); }
-| ident '(' meta_seq ')' { $$ = mk_node("MetaList", 2, $1, $3); }
-| ident '(' meta_seq ',' ')' { $$ = mk_node("MetaList", 2, $1, $3); }
-;
-
-meta_seq
-: %empty { $$ = mk_none(); }
-| meta_item { $$ = mk_node("MetaItems", 1, $1); }
-| meta_seq ',' meta_item { $$ = ext_node($1, 1, $3); }
-;
-
-maybe_mod_items
-: mod_items
-| %empty { $$ = mk_none(); }
-;
-
-mod_items
-: mod_item { $$ = mk_node("Items", 1, $1); }
-| mod_items mod_item { $$ = ext_node($1, 1, $2); }
-;
-
-attrs_and_vis
-: maybe_outer_attrs visibility { $$ = mk_node("AttrsAndVis", 2, $1, $2); }
-;
-
-mod_item
-: attrs_and_vis item { $$ = mk_node("Item", 2, $1, $2); }
-;
-
-// items that can appear outside of a fn block
-item
-: stmt_item
-| item_macro
-;
-
-// items that can appear in "stmts"
-stmt_item
-: item_static
-| item_const
-| item_type
-| block_item
-| view_item
-;
-
-item_static
-: STATIC ident ':' ty '=' expr ';' { $$ = mk_node("ItemStatic", 3, $2, $4, $6); }
-| STATIC MUT ident ':' ty '=' expr ';' { $$ = mk_node("ItemStatic", 3, $3, $5, $7); }
-;
-
-item_const
-: CONST ident ':' ty '=' expr ';' { $$ = mk_node("ItemConst", 3, $2, $4, $6); }
-;
-
-item_macro
-: path_expr '!' maybe_ident parens_delimited_token_trees ';' { $$ = mk_node("ItemMacro", 3, $1, $3, $4); }
-| path_expr '!' maybe_ident braces_delimited_token_trees { $$ = mk_node("ItemMacro", 3, $1, $3, $4); }
-| path_expr '!' maybe_ident brackets_delimited_token_trees ';'{ $$ = mk_node("ItemMacro", 3, $1, $3, $4); }
-;
-
-view_item
-: use_item
-| extern_fn_item
-| EXTERN CRATE ident ';' { $$ = mk_node("ViewItemExternCrate", 1, $3); }
-| EXTERN CRATE ident AS ident ';' { $$ = mk_node("ViewItemExternCrate", 2, $3, $5); }
-;
-
-extern_fn_item
-: EXTERN maybe_abi item_fn { $$ = mk_node("ViewItemExternFn", 2, $2, $3); }
-;
-
-use_item
-: USE view_path ';' { $$ = mk_node("ViewItemUse", 1, $2); }
-;
-
-view_path
-: path_no_types_allowed { $$ = mk_node("ViewPathSimple", 1, $1); }
-| path_no_types_allowed MOD_SEP '{' '}' { $$ = mk_node("ViewPathList", 2, $1, mk_atom("ViewPathListEmpty")); }
-| MOD_SEP '{' '}' { $$ = mk_node("ViewPathList", 1, mk_atom("ViewPathListEmpty")); }
-| path_no_types_allowed MOD_SEP '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 2, $1, $4); }
-| MOD_SEP '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 1, $3); }
-| path_no_types_allowed MOD_SEP '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 2, $1, $4); }
-| MOD_SEP '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 1, $3); }
-| path_no_types_allowed MOD_SEP '*' { $$ = mk_node("ViewPathGlob", 1, $1); }
-| MOD_SEP '*' { $$ = mk_atom("ViewPathGlob"); }
-| '*' { $$ = mk_atom("ViewPathGlob"); }
-| '{' '}' { $$ = mk_atom("ViewPathListEmpty"); }
-| '{' idents_or_self '}' { $$ = mk_node("ViewPathList", 1, $2); }
-| '{' idents_or_self ',' '}' { $$ = mk_node("ViewPathList", 1, $2); }
-| path_no_types_allowed AS ident { $$ = mk_node("ViewPathSimple", 2, $1, $3); }
-;
-
-block_item
-: item_fn
-| item_unsafe_fn
-| item_mod
-| item_foreign_mod { $$ = mk_node("ItemForeignMod", 1, $1); }
-| item_struct
-| item_enum
-| item_union
-| item_trait
-| item_impl
-;
-
-maybe_ty_ascription
-: ':' ty_sum { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_init_expr
-: '=' expr { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-// structs
-item_struct
-: STRUCT ident generic_params maybe_where_clause struct_decl_args
-{
- $$ = mk_node("ItemStruct", 4, $2, $3, $4, $5);
-}
-| STRUCT ident generic_params struct_tuple_args maybe_where_clause ';'
-{
- $$ = mk_node("ItemStruct", 4, $2, $3, $4, $5);
-}
-| STRUCT ident generic_params maybe_where_clause ';'
-{
- $$ = mk_node("ItemStruct", 3, $2, $3, $4);
-}
-;
-
-struct_decl_args
-: '{' struct_decl_fields '}' { $$ = $2; }
-| '{' struct_decl_fields ',' '}' { $$ = $2; }
-;
-
-struct_tuple_args
-: '(' struct_tuple_fields ')' { $$ = $2; }
-| '(' struct_tuple_fields ',' ')' { $$ = $2; }
-;
-
-struct_decl_fields
-: struct_decl_field { $$ = mk_node("StructFields", 1, $1); }
-| struct_decl_fields ',' struct_decl_field { $$ = ext_node($1, 1, $3); }
-| %empty { $$ = mk_none(); }
-;
-
-struct_decl_field
-: attrs_and_vis ident ':' ty_sum { $$ = mk_node("StructField", 3, $1, $2, $4); }
-;
-
-struct_tuple_fields
-: struct_tuple_field { $$ = mk_node("StructFields", 1, $1); }
-| struct_tuple_fields ',' struct_tuple_field { $$ = ext_node($1, 1, $3); }
-| %empty { $$ = mk_none(); }
-;
-
-struct_tuple_field
-: attrs_and_vis ty_sum { $$ = mk_node("StructField", 2, $1, $2); }
-;
-
-// enums
-item_enum
-: ENUM ident generic_params maybe_where_clause '{' enum_defs '}' { $$ = mk_node("ItemEnum", 0); }
-| ENUM ident generic_params maybe_where_clause '{' enum_defs ',' '}' { $$ = mk_node("ItemEnum", 0); }
-;
-
-enum_defs
-: enum_def { $$ = mk_node("EnumDefs", 1, $1); }
-| enum_defs ',' enum_def { $$ = ext_node($1, 1, $3); }
-| %empty { $$ = mk_none(); }
-;
-
-enum_def
-: attrs_and_vis ident enum_args { $$ = mk_node("EnumDef", 3, $1, $2, $3); }
-;
-
-enum_args
-: '{' struct_decl_fields '}' { $$ = mk_node("EnumArgs", 1, $2); }
-| '{' struct_decl_fields ',' '}' { $$ = mk_node("EnumArgs", 1, $2); }
-| '(' maybe_ty_sums ')' { $$ = mk_node("EnumArgs", 1, $2); }
-| '=' expr { $$ = mk_node("EnumArgs", 1, $2); }
-| %empty { $$ = mk_none(); }
-;
-
-// unions
-item_union
-: UNION ident generic_params maybe_where_clause '{' struct_decl_fields '}' { $$ = mk_node("ItemUnion", 0); }
-| UNION ident generic_params maybe_where_clause '{' struct_decl_fields ',' '}' { $$ = mk_node("ItemUnion", 0); }
-
-item_mod
-: MOD ident ';' { $$ = mk_node("ItemMod", 1, $2); }
-| MOD ident '{' maybe_mod_items '}' { $$ = mk_node("ItemMod", 2, $2, $4); }
-| MOD ident '{' inner_attrs maybe_mod_items '}' { $$ = mk_node("ItemMod", 3, $2, $4, $5); }
-;
-
-item_foreign_mod
-: EXTERN maybe_abi '{' maybe_foreign_items '}' { $$ = mk_node("ItemForeignMod", 1, $4); }
-| EXTERN maybe_abi '{' inner_attrs maybe_foreign_items '}' { $$ = mk_node("ItemForeignMod", 2, $4, $5); }
-;
-
-maybe_abi
-: str
-| %empty { $$ = mk_none(); }
-;
-
-maybe_foreign_items
-: foreign_items
-| %empty { $$ = mk_none(); }
-;
-
-foreign_items
-: foreign_item { $$ = mk_node("ForeignItems", 1, $1); }
-| foreign_items foreign_item { $$ = ext_node($1, 1, $2); }
-;
-
-foreign_item
-: attrs_and_vis STATIC item_foreign_static { $$ = mk_node("ForeignItem", 2, $1, $3); }
-| attrs_and_vis item_foreign_fn { $$ = mk_node("ForeignItem", 2, $1, $2); }
-| attrs_and_vis UNSAFE item_foreign_fn { $$ = mk_node("ForeignItem", 2, $1, $3); }
-;
-
-item_foreign_static
-: maybe_mut ident ':' ty ';' { $$ = mk_node("StaticItem", 3, $1, $2, $4); }
-;
-
-item_foreign_fn
-: FN ident generic_params fn_decl_allow_variadic maybe_where_clause ';' { $$ = mk_node("ForeignFn", 4, $2, $3, $4, $5); }
-;
-
-fn_decl_allow_variadic
-: fn_params_allow_variadic ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); }
-;
-
-fn_params_allow_variadic
-: '(' ')' { $$ = mk_none(); }
-| '(' params ')' { $$ = $2; }
-| '(' params ',' ')' { $$ = $2; }
-| '(' params ',' DOTDOTDOT ')' { $$ = $2; }
-;
-
-visibility
-: PUB { $$ = mk_atom("Public"); }
-| %empty { $$ = mk_atom("Inherited"); }
-;
-
-idents_or_self
-: ident_or_self { $$ = mk_node("IdentsOrSelf", 1, $1); }
-| idents_or_self AS ident { $$ = mk_node("IdentsOrSelf", 2, $1, $3); }
-| idents_or_self ',' ident_or_self { $$ = ext_node($1, 1, $3); }
-;
-
-ident_or_self
-: ident
-| SELF { $$ = mk_atom(yytext); }
-;
-
-item_type
-: TYPE ident generic_params maybe_where_clause '=' ty_sum ';' { $$ = mk_node("ItemTy", 4, $2, $3, $4, $6); }
-;
-
-for_sized
-: FOR '?' ident { $$ = mk_node("ForSized", 1, $3); }
-| FOR ident '?' { $$ = mk_node("ForSized", 1, $2); }
-| %empty { $$ = mk_none(); }
-;
-
-item_trait
-: maybe_unsafe TRAIT ident generic_params for_sized maybe_ty_param_bounds maybe_where_clause '{' maybe_trait_items '}'
-{
- $$ = mk_node("ItemTrait", 7, $1, $3, $4, $5, $6, $7, $9);
-}
-;
-
-maybe_trait_items
-: trait_items
-| %empty { $$ = mk_none(); }
-;
-
-trait_items
-: trait_item { $$ = mk_node("TraitItems", 1, $1); }
-| trait_items trait_item { $$ = ext_node($1, 1, $2); }
-;
-
-trait_item
-: trait_const
-| trait_type
-| trait_method
-| maybe_outer_attrs item_macro { $$ = mk_node("TraitMacroItem", 2, $1, $2); }
-;
-
-trait_const
-: maybe_outer_attrs CONST ident maybe_ty_ascription maybe_const_default ';' { $$ = mk_node("ConstTraitItem", 4, $1, $3, $4, $5); }
-;
-
-maybe_const_default
-: '=' expr { $$ = mk_node("ConstDefault", 1, $2); }
-| %empty { $$ = mk_none(); }
-;
-
-trait_type
-: maybe_outer_attrs TYPE ty_param ';' { $$ = mk_node("TypeTraitItem", 2, $1, $3); }
-;
-
-maybe_unsafe
-: UNSAFE { $$ = mk_atom("Unsafe"); }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_default_maybe_unsafe
-: DEFAULT UNSAFE { $$ = mk_atom("DefaultUnsafe"); }
-| DEFAULT { $$ = mk_atom("Default"); }
-| UNSAFE { $$ = mk_atom("Unsafe"); }
-| %empty { $$ = mk_none(); }
-
-trait_method
-: type_method { $$ = mk_node("Required", 1, $1); }
-| method { $$ = mk_node("Provided", 1, $1); }
-;
-
-type_method
-: maybe_outer_attrs maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';'
-{
- $$ = mk_node("TypeMethod", 6, $1, $2, $4, $5, $6, $7);
-}
-| maybe_outer_attrs CONST maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';'
-{
- $$ = mk_node("TypeMethod", 6, $1, $3, $5, $6, $7, $8);
-}
-| maybe_outer_attrs maybe_unsafe EXTERN maybe_abi FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause ';'
-{
- $$ = mk_node("TypeMethod", 7, $1, $2, $4, $6, $7, $8, $9);
-}
-;
-
-method
-: maybe_outer_attrs maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("Method", 7, $1, $2, $4, $5, $6, $7, $8);
-}
-| maybe_outer_attrs CONST maybe_unsafe FN ident generic_params fn_decl_with_self_allow_anon_params maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("Method", 7, $1, $3, $5, $6, $7, $8, $9);
-}
-| 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
-{
- $$ = mk_node("Method", 8, $1, $2, $4, $6, $7, $8, $9, $10);
-}
-;
-
-impl_method
-: attrs_and_vis maybe_default maybe_unsafe FN ident generic_params fn_decl_with_self maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("Method", 8, $1, $2, $3, $5, $6, $7, $8, $9);
-}
-| attrs_and_vis maybe_default CONST maybe_unsafe FN ident generic_params fn_decl_with_self maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("Method", 8, $1, $2, $4, $6, $7, $8, $9, $10);
-}
-| 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
-{
- $$ = mk_node("Method", 9, $1, $2, $3, $5, $7, $8, $9, $10, $11);
-}
-;
-
-// There are two forms of impl:
-//
-// impl (<...>)? TY { ... }
-// impl (<...>)? TRAIT for TY { ... }
-//
-// Unfortunately since TY can begin with '<' itself -- as part of a
-// TyQualifiedPath type -- there's an s/r conflict when we see '<' after IMPL:
-// should we reduce one of the early rules of TY (such as maybe_once)
-// or shall we continue shifting into the generic_params list for the
-// impl?
-//
-// The production parser disambiguates a different case here by
-// permitting / requiring the user to provide parens around types when
-// they are ambiguous with traits. We do the same here, regrettably,
-// by splitting ty into ty and ty_prim.
-item_impl
-: maybe_default_maybe_unsafe IMPL generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
-{
- $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8);
-}
-| maybe_default_maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
-{
- $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10);
-}
-| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
-{
- $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10);
-}
-| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
-{
- $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);
-}
-| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'
-{
- $$ = mk_node("ItemImplDefault", 3, $1, $3, $4);
-}
-| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'
-{
- $$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);
-}
-;
-
-maybe_impl_items
-: impl_items
-| %empty { $$ = mk_none(); }
-;
-
-impl_items
-: impl_item { $$ = mk_node("ImplItems", 1, $1); }
-| impl_item impl_items { $$ = ext_node($1, 1, $2); }
-;
-
-impl_item
-: impl_method
-| attrs_and_vis item_macro { $$ = mk_node("ImplMacroItem", 2, $1, $2); }
-| impl_const
-| impl_type
-;
-
-maybe_default
-: DEFAULT { $$ = mk_atom("Default"); }
-| %empty { $$ = mk_none(); }
-;
-
-impl_const
-: attrs_and_vis maybe_default item_const { $$ = mk_node("ImplConst", 3, $1, $2, $3); }
-;
-
-impl_type
-: attrs_and_vis maybe_default TYPE ident generic_params '=' ty_sum ';' { $$ = mk_node("ImplType", 5, $1, $2, $4, $5, $7); }
-;
-
-item_fn
-: FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("ItemFn", 5, $2, $3, $4, $5, $6);
-}
-| CONST FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("ItemFn", 5, $3, $4, $5, $6, $7);
-}
-;
-
-item_unsafe_fn
-: UNSAFE FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("ItemUnsafeFn", 5, $3, $4, $5, $6, $7);
-}
-| CONST UNSAFE FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("ItemUnsafeFn", 5, $4, $5, $6, $7, $8);
-}
-| UNSAFE EXTERN maybe_abi FN ident generic_params fn_decl maybe_where_clause inner_attrs_and_block
-{
- $$ = mk_node("ItemUnsafeFn", 6, $3, $5, $6, $7, $8, $9);
-}
-;
-
-fn_decl
-: fn_params ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); }
-;
-
-fn_decl_with_self
-: fn_params_with_self ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); }
-;
-
-fn_decl_with_self_allow_anon_params
-: fn_anon_params_with_self ret_ty { $$ = mk_node("FnDecl", 2, $1, $2); }
-;
-
-fn_params
-: '(' maybe_params ')' { $$ = $2; }
-;
-
-fn_anon_params
-: '(' anon_param anon_params_allow_variadic_tail ')' { $$ = ext_node($2, 1, $3); }
-| '(' ')' { $$ = mk_none(); }
-;
-
-fn_params_with_self
-: '(' maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfLower", 3, $2, $4, $5); }
-| '(' '&' maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfRegion", 3, $3, $5, $6); }
-| '(' '&' lifetime maybe_mut SELF maybe_ty_ascription maybe_comma_params ')' { $$ = mk_node("SelfRegion", 4, $3, $4, $6, $7); }
-| '(' maybe_params ')' { $$ = mk_node("SelfStatic", 1, $2); }
-;
-
-fn_anon_params_with_self
-: '(' maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfLower", 3, $2, $4, $5); }
-| '(' '&' maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfRegion", 3, $3, $5, $6); }
-| '(' '&' lifetime maybe_mut SELF maybe_ty_ascription maybe_comma_anon_params ')' { $$ = mk_node("SelfRegion", 4, $3, $4, $6, $7); }
-| '(' maybe_anon_params ')' { $$ = mk_node("SelfStatic", 1, $2); }
-;
-
-maybe_params
-: params
-| params ','
-| %empty { $$ = mk_none(); }
-;
-
-params
-: param { $$ = mk_node("Args", 1, $1); }
-| params ',' param { $$ = ext_node($1, 1, $3); }
-;
-
-param
-: pat ':' ty_sum { $$ = mk_node("Arg", 2, $1, $3); }
-;
-
-inferrable_params
-: inferrable_param { $$ = mk_node("InferrableParams", 1, $1); }
-| inferrable_params ',' inferrable_param { $$ = ext_node($1, 1, $3); }
-;
-
-inferrable_param
-: pat maybe_ty_ascription { $$ = mk_node("InferrableParam", 2, $1, $2); }
-;
-
-maybe_comma_params
-: ',' { $$ = mk_none(); }
-| ',' params { $$ = $2; }
-| ',' params ',' { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_comma_anon_params
-: ',' { $$ = mk_none(); }
-| ',' anon_params { $$ = $2; }
-| ',' anon_params ',' { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_anon_params
-: anon_params
-| anon_params ','
-| %empty { $$ = mk_none(); }
-;
-
-anon_params
-: anon_param { $$ = mk_node("Args", 1, $1); }
-| anon_params ',' anon_param { $$ = ext_node($1, 1, $3); }
-;
-
-// anon means it's allowed to be anonymous (type-only), but it can
-// still have a name
-anon_param
-: named_arg ':' ty { $$ = mk_node("Arg", 2, $1, $3); }
-| ty
-;
-
-anon_params_allow_variadic_tail
-: ',' DOTDOTDOT { $$ = mk_none(); }
-| ',' anon_param anon_params_allow_variadic_tail { $$ = mk_node("Args", 2, $2, $3); }
-| %empty { $$ = mk_none(); }
-;
-
-named_arg
-: ident
-| UNDERSCORE { $$ = mk_atom("PatWild"); }
-| '&' ident { $$ = $2; }
-| '&' UNDERSCORE { $$ = mk_atom("PatWild"); }
-| ANDAND ident { $$ = $2; }
-| ANDAND UNDERSCORE { $$ = mk_atom("PatWild"); }
-| MUT ident { $$ = $2; }
-;
-
-ret_ty
-: RARROW '!' { $$ = mk_none(); }
-| RARROW ty { $$ = mk_node("ret-ty", 1, $2); }
-| %prec IDENT %empty { $$ = mk_none(); }
-;
-
-generic_params
-: '<' '>' { $$ = mk_node("Generics", 2, mk_none(), mk_none()); }
-| '<' lifetimes '>' { $$ = mk_node("Generics", 2, $2, mk_none()); }
-| '<' lifetimes ',' '>' { $$ = mk_node("Generics", 2, $2, mk_none()); }
-| '<' lifetimes SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, mk_none()); }
-| '<' lifetimes ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, mk_none()); }
-| '<' lifetimes ',' ty_params '>' { $$ = mk_node("Generics", 2, $2, $4); }
-| '<' lifetimes ',' ty_params ',' '>' { $$ = mk_node("Generics", 2, $2, $4); }
-| '<' lifetimes ',' ty_params SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, $4); }
-| '<' lifetimes ',' ty_params ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, $2, $4); }
-| '<' ty_params '>' { $$ = mk_node("Generics", 2, mk_none(), $2); }
-| '<' ty_params ',' '>' { $$ = mk_node("Generics", 2, mk_none(), $2); }
-| '<' ty_params SHR { push_back('>'); $$ = mk_node("Generics", 2, mk_none(), $2); }
-| '<' ty_params ',' SHR { push_back('>'); $$ = mk_node("Generics", 2, mk_none(), $2); }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_where_clause
-: %empty { $$ = mk_none(); }
-| where_clause
-;
-
-where_clause
-: WHERE where_predicates { $$ = mk_node("WhereClause", 1, $2); }
-| WHERE where_predicates ',' { $$ = mk_node("WhereClause", 1, $2); }
-;
-
-where_predicates
-: where_predicate { $$ = mk_node("WherePredicates", 1, $1); }
-| where_predicates ',' where_predicate { $$ = ext_node($1, 1, $3); }
-;
-
-where_predicate
-: maybe_for_lifetimes lifetime ':' bounds { $$ = mk_node("WherePredicate", 3, $1, $2, $4); }
-| maybe_for_lifetimes ty ':' ty_param_bounds { $$ = mk_node("WherePredicate", 3, $1, $2, $4); }
-;
-
-maybe_for_lifetimes
-: FOR '<' lifetimes '>' { $$ = mk_none(); }
-| %prec FORTYPE %empty { $$ = mk_none(); }
-
-ty_params
-: ty_param { $$ = mk_node("TyParams", 1, $1); }
-| ty_params ',' ty_param { $$ = ext_node($1, 1, $3); }
-;
-
-// A path with no type parameters; e.g. `foo::bar::Baz`
-//
-// These show up in 'use' view-items, because these are processed
-// without respect to types.
-path_no_types_allowed
-: ident { $$ = mk_node("ViewPath", 1, $1); }
-| MOD_SEP ident { $$ = mk_node("ViewPath", 1, $2); }
-| SELF { $$ = mk_node("ViewPath", 1, mk_atom("Self")); }
-| MOD_SEP SELF { $$ = mk_node("ViewPath", 1, mk_atom("Self")); }
-| SUPER { $$ = mk_node("ViewPath", 1, mk_atom("Super")); }
-| MOD_SEP SUPER { $$ = mk_node("ViewPath", 1, mk_atom("Super")); }
-| path_no_types_allowed MOD_SEP ident { $$ = ext_node($1, 1, $3); }
-;
-
-// A path with a lifetime and type parameters, with no double colons
-// before the type parameters; e.g. `foo::bar<'a>::Baz`
-//
-// These show up in "trait references", the components of
-// type-parameter bounds lists, as well as in the prefix of the
-// path_generic_args_and_bounds rule, which is the full form of a
-// named typed expression.
-//
-// They do not have (nor need) an extra '::' before '<' because
-// unlike in expr context, there are no "less-than" type exprs to
-// be ambiguous with.
-path_generic_args_without_colons
-: %prec IDENT
- ident { $$ = mk_node("components", 1, $1); }
-| %prec IDENT
- ident generic_args { $$ = mk_node("components", 2, $1, $2); }
-| %prec IDENT
- ident '(' maybe_ty_sums ')' ret_ty { $$ = mk_node("components", 2, $1, $3); }
-| %prec IDENT
- path_generic_args_without_colons MOD_SEP ident { $$ = ext_node($1, 1, $3); }
-| %prec IDENT
- path_generic_args_without_colons MOD_SEP ident generic_args { $$ = ext_node($1, 2, $3, $4); }
-| %prec IDENT
- path_generic_args_without_colons MOD_SEP ident '(' maybe_ty_sums ')' ret_ty { $$ = ext_node($1, 2, $3, $5); }
-;
-
-generic_args
-: '<' generic_values '>' { $$ = $2; }
-| '<' generic_values SHR { push_back('>'); $$ = $2; }
-| '<' generic_values GE { push_back('='); $$ = $2; }
-| '<' generic_values SHREQ { push_back('>'); push_back('='); $$ = $2; }
-// If generic_args starts with "<<", the first arg must be a
-// TyQualifiedPath because that's the only type that can start with a
-// '<'. This rule parses that as the first ty_sum and then continues
-// with the rest of generic_values.
-| SHL ty_qualified_path_and_generic_values '>' { $$ = $2; }
-| SHL ty_qualified_path_and_generic_values SHR { push_back('>'); $$ = $2; }
-| SHL ty_qualified_path_and_generic_values GE { push_back('='); $$ = $2; }
-| SHL ty_qualified_path_and_generic_values SHREQ { push_back('>'); push_back('='); $$ = $2; }
-;
-
-generic_values
-: maybe_ty_sums_and_or_bindings { $$ = mk_node("GenericValues", 1, $1); }
-;
-
-maybe_ty_sums_and_or_bindings
-: ty_sums
-| ty_sums ','
-| ty_sums ',' bindings { $$ = mk_node("TySumsAndBindings", 2, $1, $3); }
-| bindings
-| bindings ','
-| %empty { $$ = mk_none(); }
-;
-
-maybe_bindings
-: ',' bindings { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-////////////////////////////////////////////////////////////////////////
-// Part 2: Patterns
-////////////////////////////////////////////////////////////////////////
-
-pat
-: UNDERSCORE { $$ = mk_atom("PatWild"); }
-| '&' pat { $$ = mk_node("PatRegion", 1, $2); }
-| '&' MUT pat { $$ = mk_node("PatRegion", 1, $3); }
-| ANDAND pat { $$ = mk_node("PatRegion", 1, mk_node("PatRegion", 1, $2)); }
-| '(' ')' { $$ = mk_atom("PatUnit"); }
-| '(' pat_tup ')' { $$ = mk_node("PatTup", 1, $2); }
-| '[' pat_vec ']' { $$ = mk_node("PatVec", 1, $2); }
-| lit_or_path
-| lit_or_path DOTDOTDOT lit_or_path { $$ = mk_node("PatRange", 2, $1, $3); }
-| path_expr '{' pat_struct '}' { $$ = mk_node("PatStruct", 2, $1, $3); }
-| path_expr '(' ')' { $$ = mk_node("PatEnum", 2, $1, mk_none()); }
-| path_expr '(' pat_tup ')' { $$ = mk_node("PatEnum", 2, $1, $3); }
-| path_expr '!' maybe_ident delimited_token_trees { $$ = mk_node("PatMac", 3, $1, $3, $4); }
-| binding_mode ident { $$ = mk_node("PatIdent", 2, $1, $2); }
-| ident '@' pat { $$ = mk_node("PatIdent", 3, mk_node("BindByValue", 1, mk_atom("MutImmutable")), $1, $3); }
-| binding_mode ident '@' pat { $$ = mk_node("PatIdent", 3, $1, $2, $4); }
-| BOX pat { $$ = mk_node("PatUniq", 1, $2); }
-| '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident { $$ = mk_node("PatQualifiedPath", 3, $2, $3, $6); }
-| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident
-{
- $$ = mk_node("PatQualifiedPath", 3, mk_node("PatQualifiedPath", 3, $2, $3, $6), $7, $10);
-}
-;
-
-pats_or
-: pat { $$ = mk_node("Pats", 1, $1); }
-| pats_or '|' pat { $$ = ext_node($1, 1, $3); }
-;
-
-binding_mode
-: REF { $$ = mk_node("BindByRef", 1, mk_atom("MutImmutable")); }
-| REF MUT { $$ = mk_node("BindByRef", 1, mk_atom("MutMutable")); }
-| MUT { $$ = mk_node("BindByValue", 1, mk_atom("MutMutable")); }
-;
-
-lit_or_path
-: path_expr { $$ = mk_node("PatLit", 1, $1); }
-| lit { $$ = mk_node("PatLit", 1, $1); }
-| '-' lit { $$ = mk_node("PatLit", 1, $2); }
-;
-
-pat_field
-: ident { $$ = mk_node("PatField", 1, $1); }
-| binding_mode ident { $$ = mk_node("PatField", 2, $1, $2); }
-| BOX ident { $$ = mk_node("PatField", 2, mk_atom("box"), $2); }
-| BOX binding_mode ident { $$ = mk_node("PatField", 3, mk_atom("box"), $2, $3); }
-| ident ':' pat { $$ = mk_node("PatField", 2, $1, $3); }
-| binding_mode ident ':' pat { $$ = mk_node("PatField", 3, $1, $2, $4); }
-| LIT_INTEGER ':' pat { $$ = mk_node("PatField", 2, mk_atom(yytext), $3); }
-;
-
-pat_fields
-: pat_field { $$ = mk_node("PatFields", 1, $1); }
-| pat_fields ',' pat_field { $$ = ext_node($1, 1, $3); }
-;
-
-pat_struct
-: pat_fields { $$ = mk_node("PatStruct", 2, $1, mk_atom("false")); }
-| pat_fields ',' { $$ = mk_node("PatStruct", 2, $1, mk_atom("false")); }
-| pat_fields ',' DOTDOT { $$ = mk_node("PatStruct", 2, $1, mk_atom("true")); }
-| DOTDOT { $$ = mk_node("PatStruct", 1, mk_atom("true")); }
-| %empty { $$ = mk_node("PatStruct", 1, mk_none()); }
-;
-
-pat_tup
-: pat_tup_elts { $$ = mk_node("PatTup", 2, $1, mk_none()); }
-| pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, mk_none()); }
-| pat_tup_elts DOTDOT { $$ = mk_node("PatTup", 2, $1, mk_none()); }
-| pat_tup_elts ',' DOTDOT { $$ = mk_node("PatTup", 2, $1, mk_none()); }
-| pat_tup_elts DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, $1, $4); }
-| pat_tup_elts DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, $4); }
-| pat_tup_elts ',' DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, $1, $5); }
-| pat_tup_elts ',' DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, $1, $5); }
-| DOTDOT ',' pat_tup_elts { $$ = mk_node("PatTup", 2, mk_none(), $3); }
-| DOTDOT ',' pat_tup_elts ',' { $$ = mk_node("PatTup", 2, mk_none(), $3); }
-| DOTDOT { $$ = mk_node("PatTup", 2, mk_none(), mk_none()); }
-;
-
-pat_tup_elts
-: pat { $$ = mk_node("PatTupElts", 1, $1); }
-| pat_tup_elts ',' pat { $$ = ext_node($1, 1, $3); }
-;
-
-pat_vec
-: pat_vec_elts { $$ = mk_node("PatVec", 2, $1, mk_none()); }
-| pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, mk_none()); }
-| pat_vec_elts DOTDOT { $$ = mk_node("PatVec", 2, $1, mk_none()); }
-| pat_vec_elts ',' DOTDOT { $$ = mk_node("PatVec", 2, $1, mk_none()); }
-| pat_vec_elts DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, $1, $4); }
-| pat_vec_elts DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, $4); }
-| pat_vec_elts ',' DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, $1, $5); }
-| pat_vec_elts ',' DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, $1, $5); }
-| DOTDOT ',' pat_vec_elts { $$ = mk_node("PatVec", 2, mk_none(), $3); }
-| DOTDOT ',' pat_vec_elts ',' { $$ = mk_node("PatVec", 2, mk_none(), $3); }
-| DOTDOT { $$ = mk_node("PatVec", 2, mk_none(), mk_none()); }
-| %empty { $$ = mk_node("PatVec", 2, mk_none(), mk_none()); }
-;
-
-pat_vec_elts
-: pat { $$ = mk_node("PatVecElts", 1, $1); }
-| pat_vec_elts ',' pat { $$ = ext_node($1, 1, $3); }
-;
-
-////////////////////////////////////////////////////////////////////////
-// Part 3: Types
-////////////////////////////////////////////////////////////////////////
-
-ty
-: ty_prim
-| ty_closure
-| '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident { $$ = mk_node("TyQualifiedPath", 3, $2, $3, $6); }
-| 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); }
-| '(' ty_sums ')' { $$ = mk_node("TyTup", 1, $2); }
-| '(' ty_sums ',' ')' { $$ = mk_node("TyTup", 1, $2); }
-| '(' ')' { $$ = mk_atom("TyNil"); }
-;
-
-ty_prim
-: %prec IDENT path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("global", 1, mk_atom("false")), $1); }
-| %prec IDENT MOD_SEP path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("global", 1, mk_atom("true")), $2); }
-| %prec IDENT SELF MOD_SEP path_generic_args_without_colons { $$ = mk_node("TyPath", 2, mk_node("self", 1, mk_atom("true")), $3); }
-| %prec IDENT path_generic_args_without_colons '!' maybe_ident delimited_token_trees { $$ = mk_node("TyMacro", 3, $1, $3, $4); }
-| %prec IDENT MOD_SEP path_generic_args_without_colons '!' maybe_ident delimited_token_trees { $$ = mk_node("TyMacro", 3, $2, $4, $5); }
-| BOX ty { $$ = mk_node("TyBox", 1, $2); }
-| '*' maybe_mut_or_const ty { $$ = mk_node("TyPtr", 2, $2, $3); }
-| '&' ty { $$ = mk_node("TyRptr", 2, mk_atom("MutImmutable"), $2); }
-| '&' MUT ty { $$ = mk_node("TyRptr", 2, mk_atom("MutMutable"), $3); }
-| ANDAND ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 2, mk_atom("MutImmutable"), $2)); }
-| ANDAND MUT ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 2, mk_atom("MutMutable"), $3)); }
-| '&' lifetime maybe_mut ty { $$ = mk_node("TyRptr", 3, $2, $3, $4); }
-| ANDAND lifetime maybe_mut ty { $$ = mk_node("TyRptr", 1, mk_node("TyRptr", 3, $2, $3, $4)); }
-| '[' ty ']' { $$ = mk_node("TyVec", 1, $2); }
-| '[' ty ',' DOTDOT expr ']' { $$ = mk_node("TyFixedLengthVec", 2, $2, $5); }
-| '[' ty ';' expr ']' { $$ = mk_node("TyFixedLengthVec", 2, $2, $4); }
-| TYPEOF '(' expr ')' { $$ = mk_node("TyTypeof", 1, $3); }
-| UNDERSCORE { $$ = mk_atom("TyInfer"); }
-| ty_bare_fn
-| for_in_type
-;
-
-ty_bare_fn
-: FN ty_fn_decl { $$ = $2; }
-| UNSAFE FN ty_fn_decl { $$ = $3; }
-| EXTERN maybe_abi FN ty_fn_decl { $$ = $4; }
-| UNSAFE EXTERN maybe_abi FN ty_fn_decl { $$ = $5; }
-;
-
-ty_fn_decl
-: generic_params fn_anon_params ret_ty { $$ = mk_node("TyFnDecl", 3, $1, $2, $3); }
-;
-
-ty_closure
-: UNSAFE '|' anon_params '|' maybe_bounds ret_ty { $$ = mk_node("TyClosure", 3, $3, $5, $6); }
-| '|' anon_params '|' maybe_bounds ret_ty { $$ = mk_node("TyClosure", 3, $2, $4, $5); }
-| UNSAFE OROR maybe_bounds ret_ty { $$ = mk_node("TyClosure", 2, $3, $4); }
-| OROR maybe_bounds ret_ty { $$ = mk_node("TyClosure", 2, $2, $3); }
-;
-
-for_in_type
-: FOR '<' maybe_lifetimes '>' for_in_type_suffix { $$ = mk_node("ForInType", 2, $3, $5); }
-;
-
-for_in_type_suffix
-: ty_bare_fn
-| trait_ref
-| ty_closure
-;
-
-maybe_mut
-: MUT { $$ = mk_atom("MutMutable"); }
-| %prec MUT %empty { $$ = mk_atom("MutImmutable"); }
-;
-
-maybe_mut_or_const
-: MUT { $$ = mk_atom("MutMutable"); }
-| CONST { $$ = mk_atom("MutImmutable"); }
-| %empty { $$ = mk_atom("MutImmutable"); }
-;
-
-ty_qualified_path_and_generic_values
-: ty_qualified_path maybe_bindings
-{
- $$ = mk_node("GenericValues", 3, mk_none(), mk_node("TySums", 1, mk_node("TySum", 1, $1)), $2);
-}
-| ty_qualified_path ',' ty_sums maybe_bindings
-{
- $$ = mk_node("GenericValues", 3, mk_none(), mk_node("TySums", 2, $1, $3), $4);
-}
-;
-
-ty_qualified_path
-: ty_sum AS trait_ref '>' MOD_SEP ident { $$ = mk_node("TyQualifiedPath", 3, $1, $3, $6); }
-| ty_sum AS trait_ref '>' MOD_SEP ident '+' ty_param_bounds { $$ = mk_node("TyQualifiedPath", 3, $1, $3, $6); }
-;
-
-maybe_ty_sums
-: ty_sums
-| ty_sums ','
-| %empty { $$ = mk_none(); }
-;
-
-ty_sums
-: ty_sum { $$ = mk_node("TySums", 1, $1); }
-| ty_sums ',' ty_sum { $$ = ext_node($1, 1, $3); }
-;
-
-ty_sum
-: ty_sum_elt { $$ = mk_node("TySum", 1, $1); }
-| ty_sum '+' ty_sum_elt { $$ = ext_node($1, 1, $3); }
-;
-
-ty_sum_elt
-: ty
-| lifetime
-;
-
-ty_prim_sum
-: ty_prim_sum_elt { $$ = mk_node("TySum", 1, $1); }
-| ty_prim_sum '+' ty_prim_sum_elt { $$ = ext_node($1, 1, $3); }
-;
-
-ty_prim_sum_elt
-: ty_prim
-| lifetime
-;
-
-maybe_ty_param_bounds
-: ':' ty_param_bounds { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-ty_param_bounds
-: boundseq
-| %empty { $$ = mk_none(); }
-;
-
-boundseq
-: polybound
-| boundseq '+' polybound { $$ = ext_node($1, 1, $3); }
-;
-
-polybound
-: FOR '<' maybe_lifetimes '>' bound { $$ = mk_node("PolyBound", 2, $3, $5); }
-| bound
-| '?' FOR '<' maybe_lifetimes '>' bound { $$ = mk_node("PolyBound", 2, $4, $6); }
-| '?' bound { $$ = $2; }
-;
-
-bindings
-: binding { $$ = mk_node("Bindings", 1, $1); }
-| bindings ',' binding { $$ = ext_node($1, 1, $3); }
-;
-
-binding
-: ident '=' ty { mk_node("Binding", 2, $1, $3); }
-;
-
-ty_param
-: ident maybe_ty_param_bounds maybe_ty_default { $$ = mk_node("TyParam", 3, $1, $2, $3); }
-| ident '?' ident maybe_ty_param_bounds maybe_ty_default { $$ = mk_node("TyParam", 4, $1, $3, $4, $5); }
-;
-
-maybe_bounds
-: %prec SHIFTPLUS
- ':' bounds { $$ = $2; }
-| %prec SHIFTPLUS %empty { $$ = mk_none(); }
-;
-
-bounds
-: bound { $$ = mk_node("bounds", 1, $1); }
-| bounds '+' bound { $$ = ext_node($1, 1, $3); }
-;
-
-bound
-: lifetime
-| trait_ref
-;
-
-maybe_ltbounds
-: %prec SHIFTPLUS
- ':' ltbounds { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-ltbounds
-: lifetime { $$ = mk_node("ltbounds", 1, $1); }
-| ltbounds '+' lifetime { $$ = ext_node($1, 1, $3); }
-;
-
-maybe_ty_default
-: '=' ty_sum { $$ = mk_node("TyDefault", 1, $2); }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_lifetimes
-: lifetimes
-| lifetimes ','
-| %empty { $$ = mk_none(); }
-;
-
-lifetimes
-: lifetime_and_bounds { $$ = mk_node("Lifetimes", 1, $1); }
-| lifetimes ',' lifetime_and_bounds { $$ = ext_node($1, 1, $3); }
-;
-
-lifetime_and_bounds
-: LIFETIME maybe_ltbounds { $$ = mk_node("lifetime", 2, mk_atom(yytext), $2); }
-| STATIC_LIFETIME { $$ = mk_atom("static_lifetime"); }
-;
-
-lifetime
-: LIFETIME { $$ = mk_node("lifetime", 1, mk_atom(yytext)); }
-| STATIC_LIFETIME { $$ = mk_atom("static_lifetime"); }
-;
-
-trait_ref
-: %prec IDENT path_generic_args_without_colons
-| %prec IDENT MOD_SEP path_generic_args_without_colons { $$ = $2; }
-;
-
-////////////////////////////////////////////////////////////////////////
-// Part 4: Blocks, statements, and expressions
-////////////////////////////////////////////////////////////////////////
-
-inner_attrs_and_block
-: '{' maybe_inner_attrs maybe_stmts '}' { $$ = mk_node("ExprBlock", 2, $2, $3); }
-;
-
-block
-: '{' maybe_stmts '}' { $$ = mk_node("ExprBlock", 1, $2); }
-;
-
-maybe_stmts
-: stmts
-| stmts nonblock_expr { $$ = ext_node($1, 1, $2); }
-| nonblock_expr
-| %empty { $$ = mk_none(); }
-;
-
-// There are two sub-grammars within a "stmts: exprs" derivation
-// depending on whether each stmt-expr is a block-expr form; this is to
-// handle the "semicolon rule" for stmt sequencing that permits
-// writing
-//
-// if foo { bar } 10
-//
-// as a sequence of two stmts (one if-expr stmt, one lit-10-expr
-// stmt). Unfortunately by permitting juxtaposition of exprs in
-// sequence like that, the non-block expr grammar has to have a
-// second limited sub-grammar that excludes the prefix exprs that
-// are ambiguous with binops. That is to say:
-//
-// {10} - 1
-//
-// should parse as (progn (progn 10) (- 1)) not (- (progn 10) 1), that
-// is to say, two statements rather than one, at least according to
-// the mainline rust parser.
-//
-// So we wind up with a 3-way split in exprs that occur in stmt lists:
-// block, nonblock-prefix, and nonblock-nonprefix.
-//
-// In non-stmts contexts, expr can relax this trichotomy.
-
-stmts
-: stmt { $$ = mk_node("stmts", 1, $1); }
-| stmts stmt { $$ = ext_node($1, 1, $2); }
-;
-
-stmt
-: maybe_outer_attrs let { $$ = $2; }
-| stmt_item
-| PUB stmt_item { $$ = $2; }
-| outer_attrs stmt_item { $$ = $2; }
-| outer_attrs PUB stmt_item { $$ = $3; }
-| full_block_expr
-| maybe_outer_attrs block { $$ = $2; }
-| nonblock_expr ';'
-| outer_attrs nonblock_expr ';' { $$ = $2; }
-| ';' { $$ = mk_none(); }
-;
-
-maybe_exprs
-: exprs
-| exprs ','
-| %empty { $$ = mk_none(); }
-;
-
-maybe_expr
-: expr
-| %empty { $$ = mk_none(); }
-;
-
-exprs
-: expr { $$ = mk_node("exprs", 1, $1); }
-| exprs ',' expr { $$ = ext_node($1, 1, $3); }
-;
-
-path_expr
-: path_generic_args_with_colons
-| MOD_SEP path_generic_args_with_colons { $$ = $2; }
-| SELF MOD_SEP path_generic_args_with_colons { $$ = mk_node("SelfPath", 1, $3); }
-;
-
-// A path with a lifetime and type parameters with double colons before
-// the type parameters; e.g. `foo::bar::<'a>::Baz::`
-//
-// These show up in expr context, in order to disambiguate from "less-than"
-// expressions.
-path_generic_args_with_colons
-: ident { $$ = mk_node("components", 1, $1); }
-| SUPER { $$ = mk_atom("Super"); }
-| path_generic_args_with_colons MOD_SEP ident { $$ = ext_node($1, 1, $3); }
-| path_generic_args_with_colons MOD_SEP SUPER { $$ = ext_node($1, 1, mk_atom("Super")); }
-| path_generic_args_with_colons MOD_SEP generic_args { $$ = ext_node($1, 1, $3); }
-;
-
-// the braces-delimited macro is a block_expr so it doesn't appear here
-macro_expr
-: path_expr '!' maybe_ident parens_delimited_token_trees { $$ = mk_node("MacroExpr", 3, $1, $3, $4); }
-| path_expr '!' maybe_ident brackets_delimited_token_trees { $$ = mk_node("MacroExpr", 3, $1, $3, $4); }
-;
-
-nonblock_expr
-: lit { $$ = mk_node("ExprLit", 1, $1); }
-| %prec IDENT
- path_expr { $$ = mk_node("ExprPath", 1, $1); }
-| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); }
-| macro_expr { $$ = mk_node("ExprMac", 1, $1); }
-| path_expr '{' struct_expr_fields '}' { $$ = mk_node("ExprStruct", 2, $1, $3); }
-| nonblock_expr '?' { $$ = mk_node("ExprTry", 1, $1); }
-| nonblock_expr '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); }
-| nonblock_expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); }
-| nonblock_expr '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); }
-| nonblock_expr '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); }
-| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); }
-| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); }
-| CONTINUE { $$ = mk_node("ExprAgain", 0); }
-| CONTINUE lifetime { $$ = mk_node("ExprAgain", 1, $2); }
-| RETURN { $$ = mk_node("ExprRet", 0); }
-| RETURN expr { $$ = mk_node("ExprRet", 1, $2); }
-| BREAK { $$ = mk_node("ExprBreak", 0); }
-| BREAK lifetime { $$ = mk_node("ExprBreak", 1, $2); }
-| YIELD { $$ = mk_node("ExprYield", 0); }
-| YIELD expr { $$ = mk_node("ExprYield", 1, $2); }
-| nonblock_expr '=' expr { $$ = mk_node("ExprAssign", 2, $1, $3); }
-| nonblock_expr SHLEQ expr { $$ = mk_node("ExprAssignShl", 2, $1, $3); }
-| nonblock_expr SHREQ expr { $$ = mk_node("ExprAssignShr", 2, $1, $3); }
-| nonblock_expr MINUSEQ expr { $$ = mk_node("ExprAssignSub", 2, $1, $3); }
-| nonblock_expr ANDEQ expr { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); }
-| nonblock_expr OREQ expr { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); }
-| nonblock_expr PLUSEQ expr { $$ = mk_node("ExprAssignAdd", 2, $1, $3); }
-| nonblock_expr STAREQ expr { $$ = mk_node("ExprAssignMul", 2, $1, $3); }
-| nonblock_expr SLASHEQ expr { $$ = mk_node("ExprAssignDiv", 2, $1, $3); }
-| nonblock_expr CARETEQ expr { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); }
-| nonblock_expr PERCENTEQ expr { $$ = mk_node("ExprAssignRem", 2, $1, $3); }
-| nonblock_expr OROR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); }
-| nonblock_expr ANDAND expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); }
-| nonblock_expr EQEQ expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); }
-| nonblock_expr NE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); }
-| nonblock_expr '<' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); }
-| nonblock_expr '>' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); }
-| nonblock_expr LE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); }
-| nonblock_expr GE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); }
-| nonblock_expr '|' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); }
-| nonblock_expr '^' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); }
-| nonblock_expr '&' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); }
-| nonblock_expr SHL expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); }
-| nonblock_expr SHR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); }
-| nonblock_expr '+' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); }
-| nonblock_expr '-' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); }
-| nonblock_expr '*' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); }
-| nonblock_expr '/' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); }
-| nonblock_expr '%' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); }
-| nonblock_expr DOTDOT { $$ = mk_node("ExprRange", 2, $1, mk_none()); }
-| nonblock_expr DOTDOT expr { $$ = mk_node("ExprRange", 2, $1, $3); }
-| DOTDOT expr { $$ = mk_node("ExprRange", 2, mk_none(), $2); }
-| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); }
-| nonblock_expr AS ty { $$ = mk_node("ExprCast", 2, $1, $3); }
-| nonblock_expr ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); }
-| BOX expr { $$ = mk_node("ExprBox", 1, $2); }
-| expr_qualified_path
-| nonblock_prefix_expr
-;
-
-expr
-: lit { $$ = mk_node("ExprLit", 1, $1); }
-| %prec IDENT
- path_expr { $$ = mk_node("ExprPath", 1, $1); }
-| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); }
-| macro_expr { $$ = mk_node("ExprMac", 1, $1); }
-| path_expr '{' struct_expr_fields '}' { $$ = mk_node("ExprStruct", 2, $1, $3); }
-| expr '?' { $$ = mk_node("ExprTry", 1, $1); }
-| expr '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); }
-| expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); }
-| expr '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); }
-| expr '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); }
-| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); }
-| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); }
-| CONTINUE { $$ = mk_node("ExprAgain", 0); }
-| CONTINUE ident { $$ = mk_node("ExprAgain", 1, $2); }
-| RETURN { $$ = mk_node("ExprRet", 0); }
-| RETURN expr { $$ = mk_node("ExprRet", 1, $2); }
-| BREAK { $$ = mk_node("ExprBreak", 0); }
-| BREAK ident { $$ = mk_node("ExprBreak", 1, $2); }
-| YIELD { $$ = mk_node("ExprYield", 0); }
-| YIELD expr { $$ = mk_node("ExprYield", 1, $2); }
-| expr '=' expr { $$ = mk_node("ExprAssign", 2, $1, $3); }
-| expr SHLEQ expr { $$ = mk_node("ExprAssignShl", 2, $1, $3); }
-| expr SHREQ expr { $$ = mk_node("ExprAssignShr", 2, $1, $3); }
-| expr MINUSEQ expr { $$ = mk_node("ExprAssignSub", 2, $1, $3); }
-| expr ANDEQ expr { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); }
-| expr OREQ expr { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); }
-| expr PLUSEQ expr { $$ = mk_node("ExprAssignAdd", 2, $1, $3); }
-| expr STAREQ expr { $$ = mk_node("ExprAssignMul", 2, $1, $3); }
-| expr SLASHEQ expr { $$ = mk_node("ExprAssignDiv", 2, $1, $3); }
-| expr CARETEQ expr { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); }
-| expr PERCENTEQ expr { $$ = mk_node("ExprAssignRem", 2, $1, $3); }
-| expr OROR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); }
-| expr ANDAND expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); }
-| expr EQEQ expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); }
-| expr NE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); }
-| expr '<' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); }
-| expr '>' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); }
-| expr LE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); }
-| expr GE expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); }
-| expr '|' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); }
-| expr '^' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); }
-| expr '&' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); }
-| expr SHL expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); }
-| expr SHR expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); }
-| expr '+' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); }
-| expr '-' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); }
-| expr '*' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); }
-| expr '/' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); }
-| expr '%' expr { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); }
-| expr DOTDOT { $$ = mk_node("ExprRange", 2, $1, mk_none()); }
-| expr DOTDOT expr { $$ = mk_node("ExprRange", 2, $1, $3); }
-| DOTDOT expr { $$ = mk_node("ExprRange", 2, mk_none(), $2); }
-| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); }
-| expr AS ty { $$ = mk_node("ExprCast", 2, $1, $3); }
-| expr ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); }
-| BOX expr { $$ = mk_node("ExprBox", 1, $2); }
-| expr_qualified_path
-| block_expr
-| block
-| nonblock_prefix_expr
-;
-
-expr_nostruct
-: lit { $$ = mk_node("ExprLit", 1, $1); }
-| %prec IDENT
- path_expr { $$ = mk_node("ExprPath", 1, $1); }
-| SELF { $$ = mk_node("ExprPath", 1, mk_node("ident", 1, mk_atom("self"))); }
-| macro_expr { $$ = mk_node("ExprMac", 1, $1); }
-| expr_nostruct '?' { $$ = mk_node("ExprTry", 1, $1); }
-| expr_nostruct '.' path_generic_args_with_colons { $$ = mk_node("ExprField", 2, $1, $3); }
-| expr_nostruct '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); }
-| expr_nostruct '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 2, $1, $3); }
-| expr_nostruct '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 2, $1, $3); }
-| '[' vec_expr ']' { $$ = mk_node("ExprVec", 1, $2); }
-| '(' maybe_exprs ')' { $$ = mk_node("ExprParen", 1, $2); }
-| CONTINUE { $$ = mk_node("ExprAgain", 0); }
-| CONTINUE ident { $$ = mk_node("ExprAgain", 1, $2); }
-| RETURN { $$ = mk_node("ExprRet", 0); }
-| RETURN expr { $$ = mk_node("ExprRet", 1, $2); }
-| BREAK { $$ = mk_node("ExprBreak", 0); }
-| BREAK ident { $$ = mk_node("ExprBreak", 1, $2); }
-| YIELD { $$ = mk_node("ExprYield", 0); }
-| YIELD expr { $$ = mk_node("ExprYield", 1, $2); }
-| expr_nostruct '=' expr_nostruct { $$ = mk_node("ExprAssign", 2, $1, $3); }
-| expr_nostruct SHLEQ expr_nostruct { $$ = mk_node("ExprAssignShl", 2, $1, $3); }
-| expr_nostruct SHREQ expr_nostruct { $$ = mk_node("ExprAssignShr", 2, $1, $3); }
-| expr_nostruct MINUSEQ expr_nostruct { $$ = mk_node("ExprAssignSub", 2, $1, $3); }
-| expr_nostruct ANDEQ expr_nostruct { $$ = mk_node("ExprAssignBitAnd", 2, $1, $3); }
-| expr_nostruct OREQ expr_nostruct { $$ = mk_node("ExprAssignBitOr", 2, $1, $3); }
-| expr_nostruct PLUSEQ expr_nostruct { $$ = mk_node("ExprAssignAdd", 2, $1, $3); }
-| expr_nostruct STAREQ expr_nostruct { $$ = mk_node("ExprAssignMul", 2, $1, $3); }
-| expr_nostruct SLASHEQ expr_nostruct { $$ = mk_node("ExprAssignDiv", 2, $1, $3); }
-| expr_nostruct CARETEQ expr_nostruct { $$ = mk_node("ExprAssignBitXor", 2, $1, $3); }
-| expr_nostruct PERCENTEQ expr_nostruct { $$ = mk_node("ExprAssignRem", 2, $1, $3); }
-| expr_nostruct OROR expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiOr"), $1, $3); }
-| expr_nostruct ANDAND expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiAnd"), $1, $3); }
-| expr_nostruct EQEQ expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiEq"), $1, $3); }
-| expr_nostruct NE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiNe"), $1, $3); }
-| expr_nostruct '<' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiLt"), $1, $3); }
-| expr_nostruct '>' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiGt"), $1, $3); }
-| expr_nostruct LE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiLe"), $1, $3); }
-| expr_nostruct GE expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiGe"), $1, $3); }
-| expr_nostruct '|' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitOr"), $1, $3); }
-| expr_nostruct '^' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitXor"), $1, $3); }
-| expr_nostruct '&' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiBitAnd"), $1, $3); }
-| expr_nostruct SHL expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiShl"), $1, $3); }
-| expr_nostruct SHR expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiShr"), $1, $3); }
-| expr_nostruct '+' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiAdd"), $1, $3); }
-| expr_nostruct '-' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiSub"), $1, $3); }
-| expr_nostruct '*' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiMul"), $1, $3); }
-| expr_nostruct '/' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiDiv"), $1, $3); }
-| expr_nostruct '%' expr_nostruct { $$ = mk_node("ExprBinary", 3, mk_atom("BiRem"), $1, $3); }
-| expr_nostruct DOTDOT %prec RANGE { $$ = mk_node("ExprRange", 2, $1, mk_none()); }
-| expr_nostruct DOTDOT expr_nostruct { $$ = mk_node("ExprRange", 2, $1, $3); }
-| DOTDOT expr_nostruct { $$ = mk_node("ExprRange", 2, mk_none(), $2); }
-| DOTDOT { $$ = mk_node("ExprRange", 2, mk_none(), mk_none()); }
-| expr_nostruct AS ty { $$ = mk_node("ExprCast", 2, $1, $3); }
-| expr_nostruct ':' ty { $$ = mk_node("ExprTypeAscr", 2, $1, $3); }
-| BOX expr { $$ = mk_node("ExprBox", 1, $2); }
-| expr_qualified_path
-| block_expr
-| block
-| nonblock_prefix_expr_nostruct
-;
-
-nonblock_prefix_expr_nostruct
-: '-' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnNeg"), $2); }
-| '!' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnNot"), $2); }
-| '*' expr_nostruct { $$ = mk_node("ExprUnary", 2, mk_atom("UnDeref"), $2); }
-| '&' maybe_mut expr_nostruct { $$ = mk_node("ExprAddrOf", 2, $2, $3); }
-| ANDAND maybe_mut expr_nostruct { $$ = mk_node("ExprAddrOf", 1, mk_node("ExprAddrOf", 2, $2, $3)); }
-| lambda_expr_nostruct
-| MOVE lambda_expr_nostruct { $$ = $2; }
-;
-
-nonblock_prefix_expr
-: '-' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnNeg"), $2); }
-| '!' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnNot"), $2); }
-| '*' expr { $$ = mk_node("ExprUnary", 2, mk_atom("UnDeref"), $2); }
-| '&' maybe_mut expr { $$ = mk_node("ExprAddrOf", 2, $2, $3); }
-| ANDAND maybe_mut expr { $$ = mk_node("ExprAddrOf", 1, mk_node("ExprAddrOf", 2, $2, $3)); }
-| lambda_expr
-| MOVE lambda_expr { $$ = $2; }
-;
-
-expr_qualified_path
-: '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_qpath_params
-{
- $$ = mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7);
-}
-| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident
-{
- $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10);
-}
-| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident
-{
- $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11);
-}
-| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident generic_args
-{
- $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10, $11);
-}
-| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident generic_args
-{
- $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11, $12);
-}
-
-maybe_qpath_params
-: MOD_SEP generic_args { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_as_trait_ref
-: AS trait_ref { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-lambda_expr
-: %prec LAMBDA
- OROR ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); }
-| %prec LAMBDA
- '|' '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $3, $4); }
-| %prec LAMBDA
- '|' inferrable_params '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, $2, $4, $5); }
-| %prec LAMBDA
- '|' inferrable_params OROR lambda_expr_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $2, mk_none(), $4); }
-;
-
-lambda_expr_no_first_bar
-: %prec LAMBDA
- '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); }
-| %prec LAMBDA
- inferrable_params '|' ret_ty expr { $$ = mk_node("ExprFnBlock", 3, $1, $3, $4); }
-| %prec LAMBDA
- inferrable_params OROR lambda_expr_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $1, mk_none(), $3); }
-;
-
-lambda_expr_nostruct
-: %prec LAMBDA
- OROR expr_nostruct { $$ = mk_node("ExprFnBlock", 2, mk_none(), $2); }
-| %prec LAMBDA
- '|' '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, mk_none(), $3, $4); }
-| %prec LAMBDA
- '|' inferrable_params '|' expr_nostruct { $$ = mk_node("ExprFnBlock", 2, $2, $4); }
-| %prec LAMBDA
- '|' inferrable_params OROR lambda_expr_nostruct_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $2, mk_none(), $4); }
-;
-
-lambda_expr_nostruct_no_first_bar
-: %prec LAMBDA
- '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, mk_none(), $2, $3); }
-| %prec LAMBDA
- inferrable_params '|' ret_ty expr_nostruct { $$ = mk_node("ExprFnBlock", 3, $1, $3, $4); }
-| %prec LAMBDA
- inferrable_params OROR lambda_expr_nostruct_no_first_bar { $$ = mk_node("ExprFnBlock", 3, $1, mk_none(), $3); }
-;
-
-vec_expr
-: maybe_exprs
-| exprs ';' expr { $$ = mk_node("VecRepeat", 2, $1, $3); }
-;
-
-struct_expr_fields
-: field_inits
-| field_inits ','
-| maybe_field_inits default_field_init { $$ = ext_node($1, 1, $2); }
-| %empty { $$ = mk_none(); }
-;
-
-maybe_field_inits
-: field_inits
-| field_inits ','
-| %empty { $$ = mk_none(); }
-;
-
-field_inits
-: field_init { $$ = mk_node("FieldInits", 1, $1); }
-| field_inits ',' field_init { $$ = ext_node($1, 1, $3); }
-;
-
-field_init
-: ident { $$ = mk_node("FieldInit", 1, $1); }
-| ident ':' expr { $$ = mk_node("FieldInit", 2, $1, $3); }
-| LIT_INTEGER ':' expr { $$ = mk_node("FieldInit", 2, mk_atom(yytext), $3); }
-;
-
-default_field_init
-: DOTDOT expr { $$ = mk_node("DefaultFieldInit", 1, $2); }
-;
-
-block_expr
-: expr_match
-| expr_if
-| expr_if_let
-| expr_while
-| expr_while_let
-| expr_loop
-| expr_for
-| UNSAFE block { $$ = mk_node("UnsafeBlock", 1, $2); }
-| path_expr '!' maybe_ident braces_delimited_token_trees { $$ = mk_node("Macro", 3, $1, $3, $4); }
-;
-
-full_block_expr
-: block_expr
-| block_expr_dot
-;
-
-block_expr_dot
-: block_expr '.' path_generic_args_with_colons %prec IDENT { $$ = mk_node("ExprField", 2, $1, $3); }
-| block_expr_dot '.' path_generic_args_with_colons %prec IDENT { $$ = mk_node("ExprField", 2, $1, $3); }
-| block_expr '.' path_generic_args_with_colons '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 3, $1, $3, $5); }
-| block_expr_dot '.' path_generic_args_with_colons '[' maybe_expr ']' { $$ = mk_node("ExprIndex", 3, $1, $3, $5); }
-| block_expr '.' path_generic_args_with_colons '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 3, $1, $3, $5); }
-| block_expr_dot '.' path_generic_args_with_colons '(' maybe_exprs ')' { $$ = mk_node("ExprCall", 3, $1, $3, $5); }
-| block_expr '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); }
-| block_expr_dot '.' LIT_INTEGER { $$ = mk_node("ExprTupleIndex", 1, $1); }
-;
-
-expr_match
-: MATCH expr_nostruct '{' '}' { $$ = mk_node("ExprMatch", 1, $2); }
-| MATCH expr_nostruct '{' match_clauses '}' { $$ = mk_node("ExprMatch", 2, $2, $4); }
-| MATCH expr_nostruct '{' match_clauses nonblock_match_clause '}' { $$ = mk_node("ExprMatch", 2, $2, ext_node($4, 1, $5)); }
-| MATCH expr_nostruct '{' nonblock_match_clause '}' { $$ = mk_node("ExprMatch", 2, $2, mk_node("Arms", 1, $4)); }
-;
-
-match_clauses
-: match_clause { $$ = mk_node("Arms", 1, $1); }
-| match_clauses match_clause { $$ = ext_node($1, 1, $2); }
-;
-
-match_clause
-: nonblock_match_clause ','
-| block_match_clause
-| block_match_clause ','
-;
-
-nonblock_match_clause
-: maybe_outer_attrs pats_or maybe_guard FAT_ARROW nonblock_expr { $$ = mk_node("ArmNonblock", 4, $1, $2, $3, $5); }
-| maybe_outer_attrs pats_or maybe_guard FAT_ARROW block_expr_dot { $$ = mk_node("ArmNonblock", 4, $1, $2, $3, $5); }
-;
-
-block_match_clause
-: maybe_outer_attrs pats_or maybe_guard FAT_ARROW block { $$ = mk_node("ArmBlock", 4, $1, $2, $3, $5); }
-| maybe_outer_attrs pats_or maybe_guard FAT_ARROW block_expr { $$ = mk_node("ArmBlock", 4, $1, $2, $3, $5); }
-;
-
-maybe_guard
-: IF expr_nostruct { $$ = $2; }
-| %empty { $$ = mk_none(); }
-;
-
-expr_if
-: IF expr_nostruct block { $$ = mk_node("ExprIf", 2, $2, $3); }
-| IF expr_nostruct block ELSE block_or_if { $$ = mk_node("ExprIf", 3, $2, $3, $5); }
-;
-
-expr_if_let
-: IF LET pat '=' expr_nostruct block { $$ = mk_node("ExprIfLet", 3, $3, $5, $6); }
-| IF LET pat '=' expr_nostruct block ELSE block_or_if { $$ = mk_node("ExprIfLet", 4, $3, $5, $6, $8); }
-;
-
-block_or_if
-: block
-| expr_if
-| expr_if_let
-;
-
-expr_while
-: maybe_label WHILE expr_nostruct block { $$ = mk_node("ExprWhile", 3, $1, $3, $4); }
-;
-
-expr_while_let
-: maybe_label WHILE LET pat '=' expr_nostruct block { $$ = mk_node("ExprWhileLet", 4, $1, $4, $6, $7); }
-;
-
-expr_loop
-: maybe_label LOOP block { $$ = mk_node("ExprLoop", 2, $1, $3); }
-;
-
-expr_for
-: maybe_label FOR pat IN expr_nostruct block { $$ = mk_node("ExprForLoop", 4, $1, $3, $5, $6); }
-;
-
-maybe_label
-: lifetime ':'
-| %empty { $$ = mk_none(); }
-;
-
-let
-: LET pat maybe_ty_ascription maybe_init_expr ';' { $$ = mk_node("DeclLocal", 3, $2, $3, $4); }
-;
-
-////////////////////////////////////////////////////////////////////////
-// Part 5: Macros and misc. rules
-////////////////////////////////////////////////////////////////////////
-
-lit
-: LIT_BYTE { $$ = mk_node("LitByte", 1, mk_atom(yytext)); }
-| LIT_CHAR { $$ = mk_node("LitChar", 1, mk_atom(yytext)); }
-| LIT_INTEGER { $$ = mk_node("LitInteger", 1, mk_atom(yytext)); }
-| LIT_FLOAT { $$ = mk_node("LitFloat", 1, mk_atom(yytext)); }
-| TRUE { $$ = mk_node("LitBool", 1, mk_atom(yytext)); }
-| FALSE { $$ = mk_node("LitBool", 1, mk_atom(yytext)); }
-| str
-;
-
-str
-: LIT_STR { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("CookedStr")); }
-| LIT_STR_RAW { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("RawStr")); }
-| LIT_BYTE_STR { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("ByteStr")); }
-| LIT_BYTE_STR_RAW { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("RawByteStr")); }
-;
-
-maybe_ident
-: %empty { $$ = mk_none(); }
-| ident
-;
-
-ident
-: IDENT { $$ = mk_node("ident", 1, mk_atom(yytext)); }
-// Weak keywords that can be used as identifiers
-| CATCH { $$ = mk_node("ident", 1, mk_atom(yytext)); }
-| DEFAULT { $$ = mk_node("ident", 1, mk_atom(yytext)); }
-| UNION { $$ = mk_node("ident", 1, mk_atom(yytext)); }
-;
-
-unpaired_token
-: SHL { $$ = mk_atom(yytext); }
-| SHR { $$ = mk_atom(yytext); }
-| LE { $$ = mk_atom(yytext); }
-| EQEQ { $$ = mk_atom(yytext); }
-| NE { $$ = mk_atom(yytext); }
-| GE { $$ = mk_atom(yytext); }
-| ANDAND { $$ = mk_atom(yytext); }
-| OROR { $$ = mk_atom(yytext); }
-| LARROW { $$ = mk_atom(yytext); }
-| SHLEQ { $$ = mk_atom(yytext); }
-| SHREQ { $$ = mk_atom(yytext); }
-| MINUSEQ { $$ = mk_atom(yytext); }
-| ANDEQ { $$ = mk_atom(yytext); }
-| OREQ { $$ = mk_atom(yytext); }
-| PLUSEQ { $$ = mk_atom(yytext); }
-| STAREQ { $$ = mk_atom(yytext); }
-| SLASHEQ { $$ = mk_atom(yytext); }
-| CARETEQ { $$ = mk_atom(yytext); }
-| PERCENTEQ { $$ = mk_atom(yytext); }
-| DOTDOT { $$ = mk_atom(yytext); }
-| DOTDOTDOT { $$ = mk_atom(yytext); }
-| MOD_SEP { $$ = mk_atom(yytext); }
-| RARROW { $$ = mk_atom(yytext); }
-| FAT_ARROW { $$ = mk_atom(yytext); }
-| LIT_BYTE { $$ = mk_atom(yytext); }
-| LIT_CHAR { $$ = mk_atom(yytext); }
-| LIT_INTEGER { $$ = mk_atom(yytext); }
-| LIT_FLOAT { $$ = mk_atom(yytext); }
-| LIT_STR { $$ = mk_atom(yytext); }
-| LIT_STR_RAW { $$ = mk_atom(yytext); }
-| LIT_BYTE_STR { $$ = mk_atom(yytext); }
-| LIT_BYTE_STR_RAW { $$ = mk_atom(yytext); }
-| IDENT { $$ = mk_atom(yytext); }
-| UNDERSCORE { $$ = mk_atom(yytext); }
-| LIFETIME { $$ = mk_atom(yytext); }
-| SELF { $$ = mk_atom(yytext); }
-| STATIC { $$ = mk_atom(yytext); }
-| ABSTRACT { $$ = mk_atom(yytext); }
-| ALIGNOF { $$ = mk_atom(yytext); }
-| AS { $$ = mk_atom(yytext); }
-| BECOME { $$ = mk_atom(yytext); }
-| BREAK { $$ = mk_atom(yytext); }
-| CATCH { $$ = mk_atom(yytext); }
-| CRATE { $$ = mk_atom(yytext); }
-| DEFAULT { $$ = mk_atom(yytext); }
-| DO { $$ = mk_atom(yytext); }
-| ELSE { $$ = mk_atom(yytext); }
-| ENUM { $$ = mk_atom(yytext); }
-| EXTERN { $$ = mk_atom(yytext); }
-| FALSE { $$ = mk_atom(yytext); }
-| FINAL { $$ = mk_atom(yytext); }
-| FN { $$ = mk_atom(yytext); }
-| FOR { $$ = mk_atom(yytext); }
-| IF { $$ = mk_atom(yytext); }
-| IMPL { $$ = mk_atom(yytext); }
-| IN { $$ = mk_atom(yytext); }
-| LET { $$ = mk_atom(yytext); }
-| LOOP { $$ = mk_atom(yytext); }
-| MACRO { $$ = mk_atom(yytext); }
-| MATCH { $$ = mk_atom(yytext); }
-| MOD { $$ = mk_atom(yytext); }
-| MOVE { $$ = mk_atom(yytext); }
-| MUT { $$ = mk_atom(yytext); }
-| OFFSETOF { $$ = mk_atom(yytext); }
-| OVERRIDE { $$ = mk_atom(yytext); }
-| PRIV { $$ = mk_atom(yytext); }
-| PUB { $$ = mk_atom(yytext); }
-| PURE { $$ = mk_atom(yytext); }
-| REF { $$ = mk_atom(yytext); }
-| RETURN { $$ = mk_atom(yytext); }
-| STRUCT { $$ = mk_atom(yytext); }
-| SIZEOF { $$ = mk_atom(yytext); }
-| SUPER { $$ = mk_atom(yytext); }
-| TRUE { $$ = mk_atom(yytext); }
-| TRAIT { $$ = mk_atom(yytext); }
-| TYPE { $$ = mk_atom(yytext); }
-| UNION { $$ = mk_atom(yytext); }
-| UNSAFE { $$ = mk_atom(yytext); }
-| UNSIZED { $$ = mk_atom(yytext); }
-| USE { $$ = mk_atom(yytext); }
-| VIRTUAL { $$ = mk_atom(yytext); }
-| WHILE { $$ = mk_atom(yytext); }
-| YIELD { $$ = mk_atom(yytext); }
-| CONTINUE { $$ = mk_atom(yytext); }
-| PROC { $$ = mk_atom(yytext); }
-| BOX { $$ = mk_atom(yytext); }
-| CONST { $$ = mk_atom(yytext); }
-| WHERE { $$ = mk_atom(yytext); }
-| TYPEOF { $$ = mk_atom(yytext); }
-| INNER_DOC_COMMENT { $$ = mk_atom(yytext); }
-| OUTER_DOC_COMMENT { $$ = mk_atom(yytext); }
-| SHEBANG { $$ = mk_atom(yytext); }
-| STATIC_LIFETIME { $$ = mk_atom(yytext); }
-| ';' { $$ = mk_atom(yytext); }
-| ',' { $$ = mk_atom(yytext); }
-| '.' { $$ = mk_atom(yytext); }
-| '@' { $$ = mk_atom(yytext); }
-| '#' { $$ = mk_atom(yytext); }
-| '~' { $$ = mk_atom(yytext); }
-| ':' { $$ = mk_atom(yytext); }
-| '$' { $$ = mk_atom(yytext); }
-| '=' { $$ = mk_atom(yytext); }
-| '?' { $$ = mk_atom(yytext); }
-| '!' { $$ = mk_atom(yytext); }
-| '<' { $$ = mk_atom(yytext); }
-| '>' { $$ = mk_atom(yytext); }
-| '-' { $$ = mk_atom(yytext); }
-| '&' { $$ = mk_atom(yytext); }
-| '|' { $$ = mk_atom(yytext); }
-| '+' { $$ = mk_atom(yytext); }
-| '*' { $$ = mk_atom(yytext); }
-| '/' { $$ = mk_atom(yytext); }
-| '^' { $$ = mk_atom(yytext); }
-| '%' { $$ = mk_atom(yytext); }
-;
-
-token_trees
-: %empty { $$ = mk_node("TokenTrees", 0); }
-| token_trees token_tree { $$ = ext_node($1, 1, $2); }
-;
-
-token_tree
-: delimited_token_trees
-| unpaired_token { $$ = mk_node("TTTok", 1, $1); }
-;
-
-delimited_token_trees
-: parens_delimited_token_trees
-| braces_delimited_token_trees
-| brackets_delimited_token_trees
-;
-
-parens_delimited_token_trees
-: '(' token_trees ')'
-{
- $$ = mk_node("TTDelim", 3,
- mk_node("TTTok", 1, mk_atom("(")),
- $2,
- mk_node("TTTok", 1, mk_atom(")")));
-}
-;
-
-braces_delimited_token_trees
-: '{' token_trees '}'
-{
- $$ = mk_node("TTDelim", 3,
- mk_node("TTTok", 1, mk_atom("{")),
- $2,
- mk_node("TTTok", 1, mk_atom("}")));
-}
-;
-
-brackets_delimited_token_trees
-: '[' token_trees ']'
-{
- $$ = mk_node("TTDelim", 3,
- mk_node("TTTok", 1, mk_atom("[")),
- $2,
- mk_node("TTTok", 1, mk_atom("]")));
-}
-;
diff --git a/src/grammar/raw-string-literal-ambiguity.md b/src/grammar/raw-string-literal-ambiguity.md
deleted file mode 100644
index c909f2333148a..0000000000000
--- a/src/grammar/raw-string-literal-ambiguity.md
+++ /dev/null
@@ -1,64 +0,0 @@
-Rust's lexical grammar is not context-free. Raw string literals are the source
-of the problem. Informally, a raw string literal is an `r`, followed by `N`
-hashes (where N can be zero), a quote, any characters, then a quote followed
-by `N` hashes. Critically, once inside the first pair of quotes,
-another quote cannot be followed by `N` consecutive hashes. e.g.
-`r###""###"###` is invalid.
-
-This grammar describes this as best possible:
-
- R -> 'r' S
- S -> '"' B '"'
- S -> '#' S '#'
- B -> . B
- B -> Īµ
-
-Where `.` represents any character, and `Īµ` the empty string. Consider the
-string `r#""#"#`. This string is not a valid raw string literal, but can be
-accepted as one by the above grammar, using the derivation:
-
- R : #""#"#
- S : ""#"
- S : "#
- B : #
- B : Īµ
-
-(Where `T : U` means the rule `T` is applied, and `U` is the remainder of the
-string.) The difficulty arises from the fact that it is fundamentally
-context-sensitive. In particular, the context needed is the number of hashes.
-
-To prove that Rust's string literals are not context-free, we will use
-the fact that context-free languages are closed under intersection with
-regular languages, and the
-[pumping lemma for context-free languages](https://en.wikipedia.org/wiki/Pumping_lemma_for_context-free_languages).
-
-Consider the regular language `R = r#+""#*"#+`. If Rust's raw string literals are
-context-free, then their intersection with `R`, `R'`, should also be context-free.
-Therefore, to prove that raw string literals are not context-free,
-it is sufficient to prove that `R'` is not context-free.
-
-The language `R'` is `{r#^n""#^m"#^n | m < n}`.
-
-Assume `R'` *is* context-free. Then `R'` has some pumping length `p > 0` for which
-the pumping lemma applies. Consider the following string `s` in `R'`:
-
-`r#^p""#^{p-1}"#^p`
-
-e.g. for `p = 2`: `s = r##""#"##`
-
-Then `s = uvwxy` for some choice of `uvwxy` such that `vx` is non-empty,
-`|vwx| < p+1`, and `uv^iwx^iy` is in `R'` for all `i >= 0`.
-
-Neither `v` nor `x` can contain a `"` or `r`, as the number of these characters
-in any string in `R'` is fixed. So `v` and `x` contain only hashes.
-Consequently, of the three sequences of hashes, `v` and `x` combined
-can only pump two of them.
-If we ever choose the central sequence of hashes, then one of the outer sequences
-will not grow when we pump, leading to an imbalance between the outer sequences.
-Therefore, we must pump both outer sequences of hashes. However,
-there are `p+2` characters between these two sequences of hashes, and `|vwx|` must
-be less than `p+1`. Therefore we have a contradiction, and `R'` must not be
-context-free.
-
-Since `R'` is not context-free, it follows that the Rust's raw string literals
-must not be context-free.
diff --git a/src/grammar/testparser.py b/src/grammar/testparser.py
deleted file mode 100755
index 4b5a7fb9e10b5..0000000000000
--- a/src/grammar/testparser.py
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/usr/bin/env python
-
-# ignore-tidy-linelength
-
-import sys
-
-import os
-import subprocess
-import argparse
-
-# usage: testparser.py [-h] [-p PARSER [PARSER ...]] -s SOURCE_DIR
-
-# Parsers should read from stdin and return exit status 0 for a
-# successful parse, and nonzero for an unsuccessful parse
-
-parser = argparse.ArgumentParser()
-parser.add_argument('-p', '--parser', nargs='+')
-parser.add_argument('-s', '--source-dir', nargs=1, required=True)
-args = parser.parse_args(sys.argv[1:])
-
-total = 0
-ok = {}
-bad = {}
-for parser in args.parser:
- ok[parser] = 0
- bad[parser] = []
-devnull = open(os.devnull, 'w')
-print("\n")
-
-for base, dirs, files in os.walk(args.source_dir[0]):
- for f in filter(lambda p: p.endswith('.rs'), files):
- p = os.path.join(base, f)
- parse_fail = 'parse-fail' in p
- if sys.version_info.major == 3:
- lines = open(p, encoding='utf-8').readlines()
- else:
- lines = open(p).readlines()
- if any('ignore-test' in line or 'ignore-lexer-test' in line for line in lines):
- continue
- total += 1
- for parser in args.parser:
- if subprocess.call(parser, stdin=open(p), stderr=subprocess.STDOUT, stdout=devnull) == 0:
- if parse_fail:
- bad[parser].append(p)
- else:
- ok[parser] += 1
- else:
- if parse_fail:
- ok[parser] += 1
- else:
- bad[parser].append(p)
- parser_stats = ', '.join(['{}: {}'.format(parser, ok[parser]) for parser in args.parser])
- sys.stdout.write("\033[K\r total: {}, {}, scanned {}"
- .format(total, os.path.relpath(parser_stats), os.path.relpath(p)))
-
-devnull.close()
-
-print("\n")
-
-for parser in args.parser:
- filename = os.path.basename(parser) + '.bad'
- print("writing {} files that did not yield the correct result with {} to {}".format(len(bad[parser]), parser, filename))
- with open(filename, "w") as f:
- for p in bad[parser]:
- f.write(p)
- f.write("\n")
diff --git a/src/grammar/tokens.h b/src/grammar/tokens.h
deleted file mode 100644
index 297e3dc841e87..0000000000000
--- a/src/grammar/tokens.h
+++ /dev/null
@@ -1,99 +0,0 @@
-enum Token {
- SHL = 257, // Parser generators reserve 0-256 for char literals
- SHR,
- LE,
- EQEQ,
- NE,
- GE,
- ANDAND,
- OROR,
- SHLEQ,
- SHREQ,
- MINUSEQ,
- ANDEQ,
- OREQ,
- PLUSEQ,
- STAREQ,
- SLASHEQ,
- CARETEQ,
- PERCENTEQ,
- DOTDOT,
- DOTDOTDOT,
- MOD_SEP,
- LARROW,
- RARROW,
- FAT_ARROW,
- LIT_BYTE,
- LIT_CHAR,
- LIT_INTEGER,
- LIT_FLOAT,
- LIT_STR,
- LIT_STR_RAW,
- LIT_BYTE_STR,
- LIT_BYTE_STR_RAW,
- IDENT,
- UNDERSCORE,
- LIFETIME,
-
- // keywords
- SELF,
- STATIC,
- ABSTRACT,
- ALIGNOF,
- AS,
- BECOME,
- BREAK,
- CATCH,
- CRATE,
- DEFAULT,
- DO,
- ELSE,
- ENUM,
- EXTERN,
- FALSE,
- FINAL,
- FN,
- FOR,
- IF,
- IMPL,
- IN,
- LET,
- LOOP,
- MACRO,
- MATCH,
- MOD,
- MOVE,
- MUT,
- OFFSETOF,
- OVERRIDE,
- PRIV,
- PUB,
- PURE,
- REF,
- RETURN,
- SIZEOF,
- STRUCT,
- SUPER,
- UNION,
- TRUE,
- TRAIT,
- TYPE,
- UNSAFE,
- UNSIZED,
- USE,
- VIRTUAL,
- WHILE,
- YIELD,
- CONTINUE,
- PROC,
- BOX,
- CONST,
- WHERE,
- TYPEOF,
- INNER_DOC_COMMENT,
- OUTER_DOC_COMMENT,
-
- SHEBANG,
- SHEBANG_LINE,
- STATIC_LIFETIME
-};
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index f9c1be20b8bc1..d22420e76dcd4 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -410,7 +410,7 @@ impl<'a> Parser<'a> {
&self.input[start..self.input.len()]
}
- /// Parses an Argument structure, or what's contained within braces inside the format string
+ /// Parses an `Argument` structure, or what's contained within braces inside the format string.
fn argument(&mut self) -> Argument<'a> {
let pos = self.position();
let format = self.format();
@@ -464,7 +464,7 @@ impl<'a> Parser<'a> {
}
/// Parses a format specifier at the current position, returning all of the
- /// relevant information in the FormatSpec struct.
+ /// relevant information in the `FormatSpec` struct.
fn format(&mut self) -> FormatSpec<'a> {
let mut spec = FormatSpec {
fill: None,
@@ -571,7 +571,7 @@ impl<'a> Parser<'a> {
spec
}
- /// Parses a Count parameter at the current position. This does not check
+ /// Parses a `Count` parameter at the current position. This does not check
/// for 'CountIsNextParam' because that is only used in precision, not
/// width.
fn count(&mut self, start: usize) -> (Count, Option) {
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 4310bafd7812a..2238a56b29d04 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -988,10 +988,12 @@ impl<'a> LoweringContext<'a> {
// lower attributes (we use the AST version) there is nowhere to keep
// the `HirId`s. We don't actually need HIR version of attributes anyway.
Attribute {
+ item: AttrItem {
+ path: attr.path.clone(),
+ tokens: self.lower_token_stream(attr.tokens.clone()),
+ },
id: attr.id,
style: attr.style,
- path: attr.path.clone(),
- tokens: self.lower_token_stream(attr.tokens.clone()),
is_sugared_doc: attr.is_sugared_doc,
span: attr.span,
}
diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs
index bdcf9e42ac2a8..23a2f115e05e2 100644
--- a/src/librustc/ich/impls_syntax.rs
+++ b/src/librustc/ich/impls_syntax.rs
@@ -196,6 +196,11 @@ impl<'a> HashStable> for ast::Path {
}
}
+impl_stable_hash_for!(struct ::syntax::ast::AttrItem {
+ path,
+ tokens,
+});
+
impl<'a> HashStable> for ast::Attribute {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
// Make sure that these have been filtered out.
@@ -203,19 +208,15 @@ impl<'a> HashStable> for ast::Attribute {
debug_assert!(!self.is_sugared_doc);
let ast::Attribute {
+ ref item,
id: _,
style,
- ref path,
- ref tokens,
is_sugared_doc: _,
span,
} = *self;
+ item.hash_stable(hcx, hasher);
style.hash_stable(hcx, hasher);
- path.hash_stable(hcx, hasher);
- for tt in tokens.trees() {
- tt.hash_stable(hcx, hasher);
- }
span.hash_stable(hcx, hasher);
}
}
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index 750ca4e32a64e..b06b63455ba4b 100644
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -23,7 +23,7 @@ use crate::ty::relate::RelateResult;
use crate::ty::subst::{GenericArg, InternalSubsts, SubstsRef};
use crate::ty::{self, GenericParamDefKind, Ty, TyCtxt, InferConst};
use crate::ty::{FloatVid, IntVid, TyVid, ConstVid};
-use crate::util::nodemap::FxHashMap;
+use crate::util::nodemap::{FxHashMap, FxHashSet};
use errors::DiagnosticBuilder;
use rustc_data_structures::sync::Lrc;
@@ -155,6 +155,8 @@ pub struct InferCtxt<'a, 'tcx> {
/// avoid reporting the same error twice.
pub reported_trait_errors: RefCell>>>,
+ pub reported_closure_mismatch: RefCell)>>,
+
/// When an error occurs, we want to avoid reporting "derived"
/// errors that are due to this original failure. Normally, we
/// handle this with the `err_count_on_creation` count, which
@@ -538,6 +540,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
selection_cache: Default::default(),
evaluation_cache: Default::default(),
reported_trait_errors: Default::default(),
+ reported_closure_mismatch: Default::default(),
tainted_by_errors_flag: Cell::new(false),
err_count_on_creation: tcx.sess.err_count(),
in_snapshot: Cell::new(false),
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
index c2d531793372a..a1c97d6c68790 100644
--- a/src/librustc/traits/error_reporting.rs
+++ b/src/librustc/traits/error_reporting.rs
@@ -24,7 +24,7 @@ use crate::hir::def_id::DefId;
use crate::infer::{self, InferCtxt};
use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
use crate::session::DiagnosticMessageId;
-use crate::ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable};
+use crate::ty::{self, AdtKind, DefIdTree, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable};
use crate::ty::GenericParamDefKind;
use crate::ty::error::ExpectedFound;
use crate::ty::fast_reject;
@@ -37,7 +37,7 @@ use errors::{Applicability, DiagnosticBuilder, pluralise};
use std::fmt;
use syntax::ast;
use syntax::symbol::{sym, kw};
-use syntax_pos::{DUMMY_SP, Span, ExpnKind};
+use syntax_pos::{DUMMY_SP, Span, ExpnKind, MultiSpan};
impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
pub fn report_fulfillment_errors(
@@ -550,7 +550,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
self.suggest_new_overflow_limit(&mut err);
}
- self.note_obligation_cause(&mut err, obligation);
+ self.note_obligation_cause_code(&mut err, &obligation.predicate, &obligation.cause.code,
+ &mut vec![]);
err.emit();
self.tcx.sess.abort_if_errors();
@@ -885,6 +886,14 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
self.tcx.hir().span_if_local(did)
).map(|sp| self.tcx.sess.source_map().def_span(sp)); // the sp could be an fn def
+ if self.reported_closure_mismatch.borrow().contains(&(span, found_span)) {
+ // We check closures twice, with obligations flowing in different directions,
+ // but we want to complain about them only once.
+ return;
+ }
+
+ self.reported_closure_mismatch.borrow_mut().insert((span, found_span));
+
let found = match found_trait_ref.skip_binder().substs.type_at(1).kind {
ty::Tuple(ref tys) => vec![ArgKind::empty(); tys.len()],
_ => vec![ArgKind::empty()],
@@ -940,7 +949,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
bug!("overflow should be handled before the `report_selection_error` path");
}
};
+
self.note_obligation_cause(&mut err, obligation);
+
err.emit();
}
@@ -1604,15 +1615,165 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
})
}
- fn note_obligation_cause(&self,
- err: &mut DiagnosticBuilder<'_>,
- obligation: &Obligation<'tcx, T>)
- where T: fmt::Display
- {
- self.note_obligation_cause_code(err,
- &obligation.predicate,
- &obligation.cause.code,
- &mut vec![]);
+ fn note_obligation_cause(
+ &self,
+ err: &mut DiagnosticBuilder<'_>,
+ obligation: &PredicateObligation<'tcx>,
+ ) {
+ // First, attempt to add note to this error with an async-await-specific
+ // message, and fall back to regular note otherwise.
+ if !self.note_obligation_cause_for_async_await(err, obligation) {
+ self.note_obligation_cause_code(err, &obligation.predicate, &obligation.cause.code,
+ &mut vec![]);
+ }
+ }
+
+ /// Adds an async-await specific note to the diagnostic:
+ ///
+ /// ```ignore (diagnostic)
+ /// note: future does not implement `std::marker::Send` because this value is used across an
+ /// await
+ /// --> $DIR/issue-64130-non-send-future-diags.rs:15:5
+ /// |
+ /// LL | let g = x.lock().unwrap();
+ /// | - has type `std::sync::MutexGuard<'_, u32>`
+ /// LL | baz().await;
+ /// | ^^^^^^^^^^^ await occurs here, with `g` maybe used later
+ /// LL | }
+ /// | - `g` is later dropped here
+ /// ```
+ ///
+ /// Returns `true` if an async-await specific note was added to the diagnostic.
+ fn note_obligation_cause_for_async_await(
+ &self,
+ err: &mut DiagnosticBuilder<'_>,
+ obligation: &PredicateObligation<'tcx>,
+ ) -> bool {
+ debug!("note_obligation_cause_for_async_await: obligation.predicate={:?} \
+ obligation.cause.span={:?}", obligation.predicate, obligation.cause.span);
+ let source_map = self.tcx.sess.source_map();
+
+ // Look into the obligation predicate to determine the type in the generator which meant
+ // that the predicate was not satisifed.
+ let (trait_ref, target_ty) = match obligation.predicate {
+ ty::Predicate::Trait(trait_predicate) =>
+ (trait_predicate.skip_binder().trait_ref, trait_predicate.skip_binder().self_ty()),
+ _ => return false,
+ };
+ debug!("note_obligation_cause_for_async_await: target_ty={:?}", target_ty);
+
+ // Attempt to detect an async-await error by looking at the obligation causes, looking
+ // for only generators, generator witnesses, opaque types or `std::future::GenFuture` to
+ // be present.
+ //
+ // When a future does not implement a trait because of a captured type in one of the
+ // generators somewhere in the call stack, then the result is a chain of obligations.
+ // Given a `async fn` A that calls a `async fn` B which captures a non-send type and that
+ // future is passed as an argument to a function C which requires a `Send` type, then the
+ // chain looks something like this:
+ //
+ // - `BuiltinDerivedObligation` with a generator witness (B)
+ // - `BuiltinDerivedObligation` with a generator (B)
+ // - `BuiltinDerivedObligation` with `std::future::GenFuture` (B)
+ // - `BuiltinDerivedObligation` with `impl std::future::Future` (B)
+ // - `BuiltinDerivedObligation` with `impl std::future::Future` (B)
+ // - `BuiltinDerivedObligation` with a generator witness (A)
+ // - `BuiltinDerivedObligation` with a generator (A)
+ // - `BuiltinDerivedObligation` with `std::future::GenFuture` (A)
+ // - `BuiltinDerivedObligation` with `impl std::future::Future` (A)
+ // - `BuiltinDerivedObligation` with `impl std::future::Future` (A)
+ // - `BindingObligation` with `impl_send (Send requirement)
+ //
+ // The first obligations in the chain can be used to get the details of the type that is
+ // captured but the entire chain must be inspected to detect this case.
+ let mut generator = None;
+ let mut next_code = Some(&obligation.cause.code);
+ while let Some(code) = next_code {
+ debug!("note_obligation_cause_for_async_await: code={:?}", code);
+ match code {
+ ObligationCauseCode::BuiltinDerivedObligation(derived_obligation) |
+ ObligationCauseCode::ImplDerivedObligation(derived_obligation) => {
+ debug!("note_obligation_cause_for_async_await: self_ty.kind={:?}",
+ derived_obligation.parent_trait_ref.self_ty().kind);
+ match derived_obligation.parent_trait_ref.self_ty().kind {
+ ty::Adt(ty::AdtDef { did, .. }, ..) if
+ self.tcx.is_diagnostic_item(sym::gen_future, *did) => {},
+ ty::Generator(did, ..) => generator = generator.or(Some(did)),
+ ty::GeneratorWitness(_) | ty::Opaque(..) => {},
+ _ => return false,
+ }
+
+ next_code = Some(derived_obligation.parent_code.as_ref());
+ },
+ ObligationCauseCode::ItemObligation(_) | ObligationCauseCode::BindingObligation(..)
+ if generator.is_some() => break,
+ _ => return false,
+ }
+ }
+
+ let generator_did = generator.expect("can only reach this if there was a generator");
+
+ // Only continue to add a note if the generator is from an `async` function.
+ let parent_node = self.tcx.parent(generator_did)
+ .and_then(|parent_did| self.tcx.hir().get_if_local(parent_did));
+ debug!("note_obligation_cause_for_async_await: parent_node={:?}", parent_node);
+ if let Some(hir::Node::Item(hir::Item {
+ kind: hir::ItemKind::Fn(_, header, _, _),
+ ..
+ })) = parent_node {
+ debug!("note_obligation_cause_for_async_await: header={:?}", header);
+ if header.asyncness != hir::IsAsync::Async {
+ return false;
+ }
+ }
+
+ let span = self.tcx.def_span(generator_did);
+ let tables = self.tcx.typeck_tables_of(generator_did);
+ debug!("note_obligation_cause_for_async_await: generator_did={:?} span={:?} ",
+ generator_did, span);
+
+ // Look for a type inside the generator interior that matches the target type to get
+ // a span.
+ let target_span = tables.generator_interior_types.iter()
+ .find(|ty::GeneratorInteriorTypeCause { ty, .. }| ty::TyS::same_type(*ty, target_ty))
+ .map(|ty::GeneratorInteriorTypeCause { span, scope_span, .. }|
+ (span, source_map.span_to_snippet(*span), scope_span));
+ if let Some((target_span, Ok(snippet), scope_span)) = target_span {
+ // Look at the last interior type to get a span for the `.await`.
+ let await_span = tables.generator_interior_types.iter().map(|i| i.span).last().unwrap();
+ let mut span = MultiSpan::from_span(await_span);
+ span.push_span_label(
+ await_span, format!("await occurs here, with `{}` maybe used later", snippet));
+
+ span.push_span_label(*target_span, format!("has type `{}`", target_ty));
+
+ // If available, use the scope span to annotate the drop location.
+ if let Some(scope_span) = scope_span {
+ span.push_span_label(
+ source_map.end_point(*scope_span),
+ format!("`{}` is later dropped here", snippet),
+ );
+ }
+
+ err.span_note(span, &format!(
+ "future does not implement `{}` as this value is used across an await",
+ trait_ref,
+ ));
+
+ // Add a note for the item obligation that remains - normally a note pointing to the
+ // bound that introduced the obligation (e.g. `T: Send`).
+ debug!("note_obligation_cause_for_async_await: next_code={:?}", next_code);
+ self.note_obligation_cause_code(
+ err,
+ &obligation.predicate,
+ next_code.unwrap(),
+ &mut Vec::new(),
+ );
+
+ true
+ } else {
+ false
+ }
}
fn note_obligation_cause_code(&self,
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 34c650b06a586..ffe1a11e81a11 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -288,6 +288,34 @@ pub struct ResolvedOpaqueTy<'tcx> {
pub substs: SubstsRef<'tcx>,
}
+/// Whenever a value may be live across a generator yield, the type of that value winds up in the
+/// `GeneratorInteriorTypeCause` struct. This struct adds additional information about such
+/// captured types that can be useful for diagnostics. In particular, it stores the span that
+/// caused a given type to be recorded, along with the scope that enclosed the value (which can
+/// be used to find the await that the value is live across).
+///
+/// For example:
+///
+/// ```ignore (pseudo-Rust)
+/// async move {
+/// let x: T = ...;
+/// foo.await
+/// ...
+/// }
+/// ```
+///
+/// Here, we would store the type `T`, the span of the value `x`, and the "scope-span" for
+/// the scope that contains `x`.
+#[derive(RustcEncodable, RustcDecodable, Clone, Debug, Eq, Hash, HashStable, PartialEq)]
+pub struct GeneratorInteriorTypeCause<'tcx> {
+ /// Type of the captured binding.
+ pub ty: Ty<'tcx>,
+ /// Span of the binding that was captured.
+ pub span: Span,
+ /// Span of the scope of the captured binding.
+ pub scope_span: Option,
+}
+
#[derive(RustcEncodable, RustcDecodable, Debug)]
pub struct TypeckTables<'tcx> {
/// The HirId::owner all ItemLocalIds in this table are relative to.
@@ -397,6 +425,10 @@ pub struct TypeckTables<'tcx> {
/// leading to the member of the struct or tuple that is used instead of the
/// entire variable.
pub upvar_list: ty::UpvarListMap,
+
+ /// Stores the type, span and optional scope span of all types
+ /// that are live across the yield of this generator (if a generator).
+ pub generator_interior_types: Vec>,
}
impl<'tcx> TypeckTables<'tcx> {
@@ -422,6 +454,7 @@ impl<'tcx> TypeckTables<'tcx> {
free_region_map: Default::default(),
concrete_opaque_types: Default::default(),
upvar_list: Default::default(),
+ generator_interior_types: Default::default(),
}
}
@@ -729,6 +762,7 @@ impl<'a, 'tcx> HashStable> for TypeckTables<'tcx> {
ref free_region_map,
ref concrete_opaque_types,
ref upvar_list,
+ ref generator_interior_types,
} = *self;
@@ -773,6 +807,7 @@ impl<'a, 'tcx> HashStable> for TypeckTables<'tcx> {
free_region_map.hash_stable(hcx, hasher);
concrete_opaque_types.hash_stable(hcx, hasher);
upvar_list.hash_stable(hcx, hasher);
+ generator_interior_types.hash_stable(hcx, hasher);
})
}
}
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 269f87c441a82..4b9117f71be5c 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -75,7 +75,7 @@ pub use self::binding::BindingMode;
pub use self::binding::BindingMode::*;
pub use self::context::{TyCtxt, FreeRegionInfo, AllArenas, tls, keep_local};
-pub use self::context::{Lift, TypeckTables, CtxtInterners, GlobalCtxt};
+pub use self::context::{Lift, GeneratorInteriorTypeCause, TypeckTables, CtxtInterners, GlobalCtxt};
pub use self::context::{
UserTypeAnnotationIndex, UserType, CanonicalUserType,
CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, ResolvedOpaqueTy,
diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 2a89c94652a24..0c7aa3582ac23 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -99,8 +99,8 @@ impl Margin {
// ```
let mut m = Margin {
- whitespace_left: if whitespace_left >= 6 { whitespace_left - 6 } else { 0 },
- span_left: if span_left >= 6 { span_left - 6 } else { 0 },
+ whitespace_left: whitespace_left.saturating_sub(6),
+ span_left: span_left.saturating_sub(6),
span_right: span_right + 6,
computed_left: 0,
computed_right: 0,
@@ -125,7 +125,7 @@ impl Margin {
} else {
self.computed_right
};
- right < line_len && line_len > self.computed_left + self.column_width
+ right < line_len && self.computed_left + self.column_width < line_len
}
fn compute(&mut self, max_line_len: usize) {
@@ -167,12 +167,10 @@ impl Margin {
}
fn right(&self, line_len: usize) -> usize {
- if max(line_len, self.computed_left) - self.computed_left <= self.column_width {
- line_len
- } else if self.computed_right > line_len {
+ if line_len.saturating_sub(self.computed_left) <= self.column_width {
line_len
} else {
- self.computed_right
+ min(line_len, self.computed_right)
}
}
}
@@ -297,81 +295,82 @@ pub trait Emitter {
source_map: &Option>,
span: &mut MultiSpan,
always_backtrace: bool) -> bool {
- let mut spans_updated = false;
+ let sm = match source_map {
+ Some(ref sm) => sm,
+ None => return false,
+ };
- if let Some(ref sm) = source_map {
- let mut before_after: Vec<(Span, Span)> = vec![];
- let mut new_labels: Vec<(Span, String)> = vec![];
+ let mut before_after: Vec<(Span, Span)> = vec![];
+ let mut new_labels: Vec<(Span, String)> = vec![];
- // First, find all the spans in <*macros> and point instead at their use site
- for sp in span.primary_spans() {
- if sp.is_dummy() {
+ // First, find all the spans in <*macros> and point instead at their use site
+ for sp in span.primary_spans() {
+ if sp.is_dummy() {
+ continue;
+ }
+ let call_sp = sm.call_span_if_macro(*sp);
+ if call_sp != *sp && !always_backtrace {
+ before_after.push((*sp, call_sp));
+ }
+ let backtrace_len = sp.macro_backtrace().len();
+ for (i, trace) in sp.macro_backtrace().iter().rev().enumerate() {
+ // Only show macro locations that are local
+ // and display them like a span_note
+ if trace.def_site_span.is_dummy() {
continue;
}
- let call_sp = sm.call_span_if_macro(*sp);
- if call_sp != *sp && !always_backtrace {
- before_after.push((*sp, call_sp));
+ if always_backtrace {
+ new_labels.push((trace.def_site_span,
+ format!("in this expansion of `{}`{}",
+ trace.macro_decl_name,
+ if backtrace_len > 2 {
+ // if backtrace_len == 1 it'll be pointed
+ // at by "in this macro invocation"
+ format!(" (#{})", i + 1)
+ } else {
+ String::new()
+ })));
}
- let backtrace_len = sp.macro_backtrace().len();
- for (i, trace) in sp.macro_backtrace().iter().rev().enumerate() {
- // Only show macro locations that are local
- // and display them like a span_note
- if trace.def_site_span.is_dummy() {
- continue;
- }
- if always_backtrace {
- new_labels.push((trace.def_site_span,
- format!("in this expansion of `{}`{}",
- trace.macro_decl_name,
- if backtrace_len > 2 {
- // if backtrace_len == 1 it'll be pointed
- // at by "in this macro invocation"
- format!(" (#{})", i + 1)
- } else {
- String::new()
- })));
- }
- // Check to make sure we're not in any <*macros>
- if !sm.span_to_filename(trace.def_site_span).is_macros() &&
- !trace.macro_decl_name.starts_with("desugaring of ") &&
- !trace.macro_decl_name.starts_with("#[") ||
- always_backtrace {
- new_labels.push((trace.call_site,
- format!("in this macro invocation{}",
- if backtrace_len > 2 && always_backtrace {
- // only specify order when the macro
- // backtrace is multiple levels deep
- format!(" (#{})", i + 1)
- } else {
- String::new()
- })));
- if !always_backtrace {
- break;
- }
+ // Check to make sure we're not in any <*macros>
+ if !sm.span_to_filename(trace.def_site_span).is_macros() &&
+ !trace.macro_decl_name.starts_with("desugaring of ") &&
+ !trace.macro_decl_name.starts_with("#[") ||
+ always_backtrace {
+ new_labels.push((trace.call_site,
+ format!("in this macro invocation{}",
+ if backtrace_len > 2 && always_backtrace {
+ // only specify order when the macro
+ // backtrace is multiple levels deep
+ format!(" (#{})", i + 1)
+ } else {
+ String::new()
+ })));
+ if !always_backtrace {
+ break;
}
}
}
- for (label_span, label_text) in new_labels {
- span.push_span_label(label_span, label_text);
+ }
+ for (label_span, label_text) in new_labels {
+ span.push_span_label(label_span, label_text);
+ }
+ for sp_label in span.span_labels() {
+ if sp_label.span.is_dummy() {
+ continue;
}
- for sp_label in span.span_labels() {
- if sp_label.span.is_dummy() {
- continue;
- }
- if sm.span_to_filename(sp_label.span.clone()).is_macros() &&
- !always_backtrace
- {
- let v = sp_label.span.macro_backtrace();
- if let Some(use_site) = v.last() {
- before_after.push((sp_label.span.clone(), use_site.call_site.clone()));
- }
+ if sm.span_to_filename(sp_label.span.clone()).is_macros() &&
+ !always_backtrace
+ {
+ let v = sp_label.span.macro_backtrace();
+ if let Some(use_site) = v.last() {
+ before_after.push((sp_label.span.clone(), use_site.call_site.clone()));
}
}
- // After we have them, make sure we replace these 'bad' def sites with their use sites
- for (before, after) in before_after {
- span.replace(before, after);
- spans_updated = true;
- }
+ }
+ // After we have them, make sure we replace these 'bad' def sites with their use sites
+ let spans_updated = !before_after.is_empty();
+ for (before, after) in before_after {
+ span.replace(before, after);
}
spans_updated
@@ -593,9 +592,9 @@ impl EmitterWriter {
let left = margin.left(source_string.len()); // Left trim
// Account for unicode characters of width !=0 that were removed.
- let left = source_string.chars().take(left).fold(0, |acc, ch| {
- acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1)
- });
+ let left = source_string.chars().take(left)
+ .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+ .sum();
self.draw_line(
buffer,
@@ -623,18 +622,16 @@ impl EmitterWriter {
// 3 | |
// 4 | | }
// | |_^ test
- if line.annotations.len() == 1 {
- if let Some(ref ann) = line.annotations.get(0) {
- if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
- if source_string.chars().take(ann.start_col).all(|c| c.is_whitespace()) {
- let style = if ann.is_primary {
- Style::UnderlinePrimary
- } else {
- Style::UnderlineSecondary
- };
- buffer.putc(line_offset, width_offset + depth - 1, '/', style);
- return vec![(depth, style)];
- }
+ if let [ann] = &line.annotations[..] {
+ if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
+ if source_string.chars().take(ann.start_col).all(|c| c.is_whitespace()) {
+ let style = if ann.is_primary {
+ Style::UnderlinePrimary
+ } else {
+ Style::UnderlineSecondary
+ };
+ buffer.putc(line_offset, width_offset + depth - 1, '/', style);
+ return vec![(depth, style)];
}
}
}
@@ -763,11 +760,7 @@ impl EmitterWriter {
annotations_position.push((p, annotation));
for (j, next) in annotations.iter().enumerate() {
if j > i {
- let l = if let Some(ref label) = next.label {
- label.len() + 2
- } else {
- 0
- };
+ let l = next.label.as_ref().map_or(0, |label| label.len() + 2);
if (overlaps(next, annotation, l) // Do not allow two labels to be in the same
// line if they overlap including padding, to
// avoid situations like:
@@ -797,9 +790,7 @@ impl EmitterWriter {
}
}
}
- if line_len < p {
- line_len = p;
- }
+ line_len = max(line_len, p);
}
if line_len != 0 {
@@ -941,17 +932,9 @@ impl EmitterWriter {
Style::LabelSecondary
};
let (pos, col) = if pos == 0 {
- (pos + 1, if annotation.end_col + 1 > left {
- annotation.end_col + 1 - left
- } else {
- 0
- })
+ (pos + 1, (annotation.end_col + 1).saturating_sub(left))
} else {
- (pos + 2, if annotation.start_col > left {
- annotation.start_col - left
- } else {
- 0
- })
+ (pos + 2, annotation.start_col.saturating_sub(left))
};
if let Some(ref label) = annotation.label {
buffer.puts(line_offset + pos, code_offset + col, &label, style);
@@ -966,9 +949,9 @@ impl EmitterWriter {
// | | |
// | | something about `foo`
// | something about `fn foo()`
- annotations_position.sort_by(|a, b| {
- // Decreasing order. When `a` and `b` are the same length, prefer `Primary`.
- (a.1.len(), !a.1.is_primary).cmp(&(b.1.len(), !b.1.is_primary)).reverse()
+ annotations_position.sort_by_key(|(_, ann)| {
+ // Decreasing order. When annotations share the same length, prefer `Primary`.
+ (Reverse(ann.len()), ann.is_primary)
});
// Write the underlines.
@@ -991,11 +974,7 @@ impl EmitterWriter {
for p in annotation.start_col..annotation.end_col {
buffer.putc(
line_offset + 1,
- if code_offset + p > left {
- code_offset + p - left
- } else {
- 0
- },
+ (code_offset + p).saturating_sub(left),
underline,
style,
);
@@ -1018,40 +997,36 @@ impl EmitterWriter {
}
fn get_multispan_max_line_num(&mut self, msp: &MultiSpan) -> usize {
+ let sm = match self.sm {
+ Some(ref sm) => sm,
+ None => return 0,
+ };
+
let mut max = 0;
- if let Some(ref sm) = self.sm {
- for primary_span in msp.primary_spans() {
- if !primary_span.is_dummy() {
- let hi = sm.lookup_char_pos(primary_span.hi());
- if hi.line > max {
- max = hi.line;
- }
- }
+ for primary_span in msp.primary_spans() {
+ if !primary_span.is_dummy() {
+ let hi = sm.lookup_char_pos(primary_span.hi());
+ max = (hi.line).max(max);
}
- if !self.short_message {
- for span_label in msp.span_labels() {
- if !span_label.span.is_dummy() {
- let hi = sm.lookup_char_pos(span_label.span.hi());
- if hi.line > max {
- max = hi.line;
- }
- }
+ }
+ if !self.short_message {
+ for span_label in msp.span_labels() {
+ if !span_label.span.is_dummy() {
+ let hi = sm.lookup_char_pos(span_label.span.hi());
+ max = (hi.line).max(max);
}
}
}
+
max
}
fn get_max_line_num(&mut self, span: &MultiSpan, children: &[SubDiagnostic]) -> usize {
-
let primary = self.get_multispan_max_line_num(span);
- let mut max = primary;
-
- for sub in children {
- let sub_result = self.get_multispan_max_line_num(&sub.span);
- max = std::cmp::max(sub_result, max);
- }
- max
+ children.iter()
+ .map(|sub| self.get_multispan_max_line_num(&sub.span))
+ .max()
+ .unwrap_or(primary)
}
/// Adds a left margin to every line but the first, given a padding length and the label being
@@ -1081,14 +1056,12 @@ impl EmitterWriter {
// `max_line_num_len`
let padding = " ".repeat(padding + label.len() + 5);
- /// Returns `true` if `style`, or the override if present and the style is `NoStyle`.
- fn style_or_override(style: Style, override_style: Option