From 170eebd7001153a849fbf84c52767240a33c4538 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 16:03:10 +0200
Subject: Rename whitespace rules

---
 dhall_parser/src/dhall.pest.visibility | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index ee5ea2b..e95cd32 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -7,9 +7,8 @@ end_of_line
 # not_end_of_line
 # line_comment
 # whitespace_chunk
-# whitespace
-# whitespace_
-# nonempty_whitespace
+# whsp
+# whsp1
 # ALPHA
 # DIGIT
 # HEXDIG
-- 
cgit v1.3.1


From a342f45f820e28638e4a73a7b3a577ebf2396b0d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 18:48:42 +0200
Subject: Factor back in some rule branches

---
 dhall_core/src/parser.rs               | 93 ++++++++++++++++++----------------
 dhall_parser/src/dhall.abnf            | 64 +++++++++++------------
 dhall_parser/src/dhall.pest.visibility | 22 +++-----
 3 files changed, 84 insertions(+), 95 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 68796c4..f888f94 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -116,8 +116,10 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 
 macro_rules! make_parser {
     (@pattern, rule, $name:ident) => (Rule::$name);
+    (@pattern, token_rule, $name:ident) => (Rule::$name);
     (@pattern, rule_group, $name:ident) => (_);
     (@filter, rule) => (true);
+    (@filter, token_rule) => (true);
     (@filter, rule_group) => (false);
 
     (@body,
@@ -164,6 +166,13 @@ macro_rules! make_parser {
         ).ok_or_else(|| -> String { unreachable!() })?;
         Ok(ParsedValue::$group(res))
     });
+    (@body,
+        $pair:expr,
+        $children:expr,
+        token_rule!($name:ident<$o:ty>)
+    ) => ({
+        Ok(ParsedValue::$name(()))
+    });
     (@body, $pair:expr, $children:expr, rule_group!( $name:ident<$o:ty> )) => (
         unreachable!()
     );
@@ -235,7 +244,8 @@ fn do_parse<'a>(initial_pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
 fn can_be_shortcutted(rule: Rule) -> bool {
     use Rule::*;
     match rule {
-        import_alt_expression
+        expression
+        | import_alt_expression
         | or_expression
         | plus_expression
         | text_append_expression
@@ -255,7 +265,7 @@ fn can_be_shortcutted(rule: Rule) -> bool {
 }
 
 make_parser! {
-    rule!(EOI<()>; captured_str!(_) => ());
+    token_rule!(EOI<()>);
 
     rule!(simple_label<Label>;
         captured_str!(s) => Label::from(s.trim().to_owned())
@@ -321,7 +331,7 @@ make_parser! {
         captured_str!(s) => s
     );
 
-    rule!(end_of_line<()>; captured_str!(_) => ());
+    token_rule!(end_of_line<()>);
 
     rule!(single_quote_literal<ParsedText>; children!(
         [end_of_line(eol), single_quote_continue(lines)] => {
@@ -392,9 +402,9 @@ make_parser! {
         },
     ));
 
-    rule!(NaN<()>; captured_str!(_) => ());
-    rule!(minus_infinity_literal<()>; captured_str!(_) => ());
-    rule!(plus_infinity_literal<()>; captured_str!(_) => ());
+    token_rule!(NaN<()>);
+    token_rule!(minus_infinity_literal<()>);
+    token_rule!(plus_infinity_literal<()>);
 
     rule!(double_literal<core::Double>;
         captured_str!(s) => {
@@ -491,7 +501,7 @@ make_parser! {
     rule!(bash_environment_variable<String>; captured_str!(s) => s.to_owned());
     rule!(posix_environment_variable<String>; captured_str!(s) => s.to_owned());
 
-    rule!(missing<()>; captured_str!(_) => ());
+    token_rule!(missing<()>);
 
     rule!(import_type<ImportLocation>; children!(
         [missing(_)] => {
@@ -522,9 +532,7 @@ make_parser! {
             ImportHashed { location, hash: Some(h) },
     ));
 
-    rule_group!(expression<ParsedExpr>);
-
-    rule!(Text<()>; captured_str!(_) => ());
+    token_rule!(Text<()>);
 
     rule!(import<ParsedExpr> as expression; children!(
         [import_hashed(location_hashed)] => {
@@ -541,25 +549,39 @@ make_parser! {
         },
     ));
 
-    rule!(lambda_expression<ParsedExpr> as expression; children!(
-        [nonreserved_label(l), expression(typ), expression(body)] => {
-            Expr::Lam(l, rc(typ), rc(body))
-        }
-    ));
+    token_rule!(lambda<()>);
+    token_rule!(forall<()>);
+    token_rule!(arrow<()>);
+    token_rule!(merge<()>);
+    token_rule!(if_<()>);
+    token_rule!(in_<()>);
 
-    rule!(ifthenelse_expression<ParsedExpr> as expression; children!(
-        [expression(cond), expression(left), expression(right)] => {
+    rule!(expression<ParsedExpr> as expression; children!(
+        [lambda(()), nonreserved_label(l), expression(typ), arrow(()), expression(body)] => {
+            Expr::Lam(l, rc(typ), rc(body))
+        },
+        [if_(()), expression(cond), expression(left), expression(right)] => {
             Expr::BoolIf(rc(cond), rc(left), rc(right))
-        }
-    ));
-
-    rule!(let_expression<ParsedExpr> as expression; children!(
-        [let_binding(bindings).., expression(final_expr)] => {
+        },
+        [let_binding(bindings).., in_(()), expression(final_expr)] => {
             bindings.fold(
                 final_expr,
                 |acc, x| Expr::Let(x.0, x.1, x.2, rc(acc))
             )
-        }
+        },
+        [forall(()), nonreserved_label(l), expression(typ), arrow(()), expression(body)] => {
+            Expr::Pi(l, rc(typ), rc(body))
+        },
+        [expression(typ), arrow(()), expression(body)] => {
+            Expr::Pi("_".into(), rc(typ), rc(body))
+        },
+        [merge(()), expression(x), expression(y), expression(z)] => {
+            Expr::Merge(rc(x), rc(y), Some(rc(z)))
+        },
+        [merge(()), expression(x), expression(y)] => {
+            Expr::Merge(rc(x), rc(y), None)
+        },
+        [expression(e)] => e,
     ));
 
     rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>; children!(
@@ -569,27 +591,8 @@ make_parser! {
             (name, None, rc(expr)),
     ));
 
-    rule!(forall_expression<ParsedExpr> as expression; children!(
-        [nonreserved_label(l), expression(typ), expression(body)] => {
-            Expr::Pi(l, rc(typ), rc(body))
-        }
-    ));
-
-    rule!(arrow_expression<ParsedExpr> as expression; children!(
-        [expression(typ), expression(body)] => {
-            Expr::Pi("_".into(), rc(typ), rc(body))
-        }
-    ));
-
-    rule!(merge_expression<ParsedExpr> as expression; children!(
-        [expression(x), expression(y), expression(z)] =>
-            Expr::Merge(rc(x), rc(y), Some(rc(z))),
-        [expression(x), expression(y)] =>
-            Expr::Merge(rc(x), rc(y), None),
-    ));
-
-    rule!(List<()>; captured_str!(_) => ());
-    rule!(Optional<()>; captured_str!(_) => ());
+    token_rule!(List<()>);
+    token_rule!(Optional<()>);
 
     rule!(empty_collection<ParsedExpr> as expression; children!(
         [List(_), expression(t)] => {
@@ -830,7 +833,7 @@ make_parser! {
         },
     ));
 
-    rule!(empty_union_type<()>; captured_str!(_) => ());
+    token_rule!(empty_union_type<()>);
 
     rule!(non_empty_union_type_or_literal
           <(Option<(Label, ParsedSubExpr)>, BTreeMap<Label, ParsedSubExpr>)>;
diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 8964f44..2fad4d4 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -529,52 +529,46 @@ import = import-hashed [ whsp as whsp1 Text ]
 ; This is important to avoid the need for sequential backtracking in application-expression.
 
 expression =
-    lambda-expression
-    / ifthenelse-expression
-    / let-expression
-    / forall-expression
+    ; "\(x : a) -> b"
+      lambda whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
+    
+    ; "if a then b else c"
+    / if whsp1 expression whsp then whsp1 expression whsp else whsp1 expression
+    
+    ; "let x : t = e1 in e2"
+    ; "let x     = e1 in e2"
+    ; "let x = e1 let y = e2 in e3"
+    / 1*let-binding in whsp1 expression
+    
+    ; "forall (x : a) -> b"
+    / forall whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
+    
+    ; "a -> b"
     ; NOTE: Backtrack if parsing this alternative fails
-    / arrow-expression
-    / merge-expression
+    / operator-expression whsp arrow whsp expression
+    
+    ; "merge e1 e2 : t"
+    ; "merge e1 e2"
+    / merge whsp1 import-expression whsp import-expression [ whsp ":" whsp1 application-expression ]
+    
+    ; "[]  : List     t"
+    ; "[]  : Optional t"
+    ; "[x] : Optional t"
     ; NOTE: Backtrack if parsing this alternative fails since we can't tell
     ; from the opening bracket whether or not this will be an empty list or
     ; a non-empty list
-    / empty-list-or-optional
+    / "[" whsp (empty-collection / non-empty-optional)
+    
+    ; "x : t"
     / annotated-expression
 
-; "\(x : a) -> b"
-lambda-expression = lambda whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
-
-; "if a then b else c"
-ifthenelse-expression = if whsp1 expression whsp then whsp1 expression whsp else whsp1 expression
+; "x : t"
+annotated-expression = operator-expression [ whsp ":" whsp1 expression ]
 
-; "let x : t = e1 in e2"
-; "let x     = e1 in e2"
-; "let x = e1 let y = e2 in e3"
-let-expression = 1*let-binding in whsp1 expression
 let-binding = let whsp1 nonreserved-label whsp [ ":" whsp1 expression whsp ] "=" whsp expression whsp
-
-; "forall (x : a) -> b"
-forall-expression = forall whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
-
-; "a -> b"
-arrow-expression = operator-expression whsp arrow whsp expression
-
-; "merge e1 e2 : t"
-; "merge e1 e2"
-merge-expression = merge whsp1 import-expression whsp import-expression [ whsp ":" whsp1 application-expression ]
-
-; "[]  : List     t"
-; "[]  : Optional t"
-; "[x] : Optional t"
-empty-list-or-optional = "[" whsp (empty-collection / non-empty-optional)
 empty-collection = "]" whsp ":" whsp1 (List / Optional) whsp import-expression
 non-empty-optional = expression whsp "]" whsp ":" whsp1 Optional whsp import-expression
 
-; "x : t"
-annotated-expression = operator-expression [ whsp ":" whsp1 expression ]
-
-
 operator-expression = import-alt-expression
 
 ; Nonempty-whitespace to disambiguate `http://a/a?a`
diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index e95cd32..ac3ea30 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -34,16 +34,15 @@ single_quote_literal
 # in
 # as
 # using
-# merge
 missing
-# if_
+if_
 # then
 # else_
 # let_
-# in_
+in_
 # as_
 # using
-# merge
+merge
 # Infinity
 Optional
 Text
@@ -78,9 +77,9 @@ List
 # combine
 # combine_types
 # prefer
-# lambda
-# forall
-# arrow
+lambda
+forall
+arrow
 # exponent
 double_literal
 natural_literal
@@ -120,14 +119,7 @@ import_type
 hash
 import_hashed
 import
-# expression
-lambda_expression
-ifthenelse_expression
-let_expression
-forall_expression
-arrow_expression
-merge_expression
-# empty_list_or_optional
+expression
 empty_collection
 non_empty_optional
 annotated_expression
-- 
cgit v1.3.1


From e05299d3d84dcbba79887f1dc5b42d689b714edc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 20:07:51 +0200
Subject: Factor literal-expression back in

---
 dhall_core/src/parser.rs               |  2 +-
 dhall_parser/src/dhall.abnf            | 16 ++++------------
 dhall_parser/src/dhall.pest.visibility |  3 +--
 3 files changed, 6 insertions(+), 15 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 55fb177..0f6978d 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -742,7 +742,7 @@ make_parser! {
         [label(ls)..] => ls.collect(),
     ));
 
-    rule!(literal_expression<ParsedExpr> as expression; children!(
+    rule!(primitive_expression<ParsedExpr> as expression; children!(
         [double_literal(n)] => Expr::DoubleLit(n),
         [natural_literal(n)] => Expr::NaturalLit(n),
         [integer_literal(n)] => Expr::IntegerLit(n),
diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 15fd898..52d5b91 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -622,15 +622,6 @@ labels = "{" whsp [ any-label whsp *("," whsp any-label whsp) ] "}"
 
 
 primitive-expression =
-      literal-expression
-    / "{" whsp record-type-or-literal "}"
-    / "<" whsp union-type-or-literal ">"
-    / non-empty-list-literal
-    / parenthesized-expression
-
-; NOTE: Backtrack when parsing the first three alternatives (i.e. the numeric
-; literals).  This is because they share leading characters in common
-literal-expression =
     ; "2.0"
       double-literal
     
@@ -646,9 +637,10 @@ literal-expression =
     ; "x"
     ; "x@2"
     / identifier
-
-minus-infinity-literal = "-" Infinity
-plus-infinity-literal = Infinity
+    / "{" whsp record-type-or-literal "}"
+    / "<" whsp union-type-or-literal ">"
+    / non-empty-list-literal
+    / parenthesized-expression
 
 record-type-or-literal =
       empty-record-literal
diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index ac3ea30..63a4179 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -142,8 +142,7 @@ application_expression
 selector_expression
 selector
 labels
-# primitive_expression
-literal_expression
+primitive_expression
 # record_type_or_literal
 empty_record_literal
 empty_record_type
-- 
cgit v1.3.1


From 3e4b2dcb8c371045737901c0d49f9d9403109ea0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 21:43:41 +0200
Subject: Get keyword rule from upstream

---
 dhall/src/normalize.rs                 | 2 +-
 dhall_parser/build.rs                  | 7 -------
 dhall_parser/src/dhall.abnf            | 9 +++++++++
 dhall_parser/src/dhall.pest.visibility | 1 +
 4 files changed, 11 insertions(+), 8 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index a3a2318..d9bd08a 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -107,7 +107,7 @@ where
                 break dhall_expr!(
                     g
                     (List a0)
-                    (λ(a : a0) -> λ(as : List a1) -> [ a ] # as)
+                    (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
                     ([] : List a0)
                 );
             }
diff --git a/dhall_parser/build.rs b/dhall_parser/build.rs
index 4e75181..615a55c 100644
--- a/dhall_parser/build.rs
+++ b/dhall_parser/build.rs
@@ -40,13 +40,6 @@ fn main() -> std::io::Result<()> {
             | !keyword ~ simple_label_first_char ~ simple_label_next_char*
     }}"
     )?;
-    writeln!(
-        &mut file,
-        "keyword = _{{
-            let_ | in_ | if_ | then
-                | else_ | Infinity | NaN
-    }}"
-    )?;
     writeln!(
         &mut file,
         "final_expression = ${{ SOI ~ complete_expression ~ EOI }}"
diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 4aa3fec..01ec6d8 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -291,6 +291,15 @@ Infinity              = %x49.6e.66.69.6e.69.74.79
 NaN                   = %x4e.61.4e
 Some                  = %x53.6f.6d.65
 
+; Unused rule that could be used as negative lookahead in the
+; `simple-label` rule for parsers that support this.
+keyword =
+      if / then / else
+    / let / in
+    / using / missing / as
+    / Infinity / NaN
+    / merge / Some
+
 ; Reserved identifiers, only needed for some special cases of parsing
 Optional              = %x4f.70.74.69.6f.6e.61.6c
 Text                  = %x54.65.78.74
diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index 63a4179..8205cc8 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -44,6 +44,7 @@ in_
 # using
 merge
 # Infinity
+# keyword
 Optional
 Text
 List
-- 
cgit v1.3.1


From af968c9e72ef5c2ea1ee965776879d9c903bd1aa Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 22:32:04 +0200
Subject: Revert end_of_line handling to upstream

---
 dhall_core/src/parser.rs               | 4 +---
 dhall_parser/src/dhall.abnf            | 9 ++++-----
 dhall_parser/src/dhall.pest.visibility | 3 +--
 3 files changed, 6 insertions(+), 10 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index c569918..b0d80c0 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -331,10 +331,8 @@ make_parser! {
         captured_str!(s) => s
     );
 
-    token_rule!(end_of_line<()>);
-
     rule!(single_quote_literal<ParsedText>; children!(
-        [end_of_line(eol), single_quote_continue(lines)] => {
+        [single_quote_continue(lines)] => {
             let space = InterpolatedTextContents::Text(" ".to_owned());
             let newline = InterpolatedTextContents::Text("\n".to_owned());
             let min_indent = lines
diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 7ad0b24..847da02 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -100,10 +100,9 @@
 ;
 ; For simplicity this supports Unix and Windows line-endings, which are the most
 ; common
-end-of-line-silent =
+end-of-line =
       %x0A     ; "\n"
     / %x0D.0A  ; "\r\n"
-end-of-line = end-of-line-silent
 
 tab = %x09  ; "\t"
 
@@ -113,7 +112,7 @@ block-comment-chunk =
       block-comment
     / %x20-10FFFF
     / tab
-    / end-of-line-silent
+    / end-of-line
 
 block-comment-continue = "-}" / block-comment-chunk block-comment-continue
 
@@ -121,12 +120,12 @@ not-end-of-line = %x20-10FFFF / tab
 
 ; NOTE: Slightly different from Haskell-style single-line comments because this
 ; does not require a space after the dashes
-line-comment = "--" *not-end-of-line end-of-line-silent
+line-comment = "--" *not-end-of-line end-of-line
 
 whitespace-chunk =
       " "
     / tab
-    / end-of-line-silent
+    / end-of-line
     / line-comment
     / block-comment
 
diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index 8205cc8..d02298e 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -1,5 +1,4 @@
-end_of_line
-# end_of_line_silent
+# end_of_line
 # tab
 # block_comment
 # block_comment_chunk
-- 
cgit v1.3.1


From 74eb88c42d938672137771fab33ef0118903b5e1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 22:46:27 +0200
Subject: Regen visibility list

---
 dhall_parser/src/dhall.pest.visibility | 66 +++++++++++++---------------------
 1 file changed, 25 insertions(+), 41 deletions(-)

(limited to 'dhall_parser/src/dhall.pest.visibility')

diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index d02298e..f881a50 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -12,28 +12,24 @@
 # DIGIT
 # HEXDIG
 # simple_label_first_char
-# simple_label_next_other_char
 # simple_label_next_char
-# simple_label_start
 simple_label
 # quoted_label_char
 quoted_label
 label
+nonreserved_label
 # any_label
 double_quote_chunk
 double_quote_escaped
+double_quote_char
 double_quote_literal
 single_quote_continue
+escaped_quote_pair
+escaped_interpolation
+single_quote_char
 single_quote_literal
+interpolation
 # text_literal
-# if
-# then
-# else
-# let
-# in
-# as
-# using
-missing
 if_
 # then
 # else_
@@ -42,38 +38,14 @@ in_
 # as_
 # using
 merge
+missing
 # Infinity
+NaN
+Some
 # keyword
 Optional
 Text
 List
-# equal
-# or
-# plus
-# text_append
-# list_append
-# and
-# times
-# double_equal
-# not_equal
-# dot
-# bar
-# comma
-# at
-# colon
-# import_alt
-# open_parens
-# close_parens
-# close_parens
-# open_brace
-# close_brace
-# close_brace
-# open_bracket
-# close_bracket
-# close_bracket
-# open_angle
-# close_angle
-# close_angle
 # combine
 # combine_types
 # prefer
@@ -81,15 +53,24 @@ lambda
 forall
 arrow
 # exponent
+numeric_double_literal
+minus_infinity_literal
+plus_infinity_literal
 double_literal
 natural_literal
 integer_literal
 identifier
 # path_character
 # quoted_path_character
+unquoted_path_component
+quoted_path_component
 path_component
 path
 # local
+parent_path
+here_path
+home_path
+absolute_path
 scheme
 http_raw
 authority
@@ -106,7 +87,6 @@ authority
 # reg_name
 # pchar
 query
-fragment
 # pct_encoded
 # unreserved
 # sub_delims
@@ -120,9 +100,10 @@ hash
 import_hashed
 import
 expression
+annotated_expression
+let_binding
 empty_collection
 non_empty_optional
-annotated_expression
 # operator_expression
 import_alt_expression
 or_expression
@@ -137,7 +118,6 @@ times_expression
 equal_expression
 not_equal_expression
 application_expression
-# atomic_expression
 # import_expression
 selector_expression
 selector
@@ -148,10 +128,14 @@ empty_record_literal
 empty_record_type
 non_empty_record_type_or_literal
 non_empty_record_type
+record_type_entry
 non_empty_record_literal
+record_literal_entry
 union_type_or_literal
 empty_union_type
 non_empty_union_type_or_literal
+union_literal_variant_value
+union_type_entry
+union_type_or_literal_variant_type
 non_empty_list_literal
-# parenthesized_expression
 # complete_expression
-- 
cgit v1.3.1