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.abnf            | 96 +++++++++++++++++-----------------
 dhall_parser/src/dhall.pest.visibility |  5 +-
 2 files changed, 50 insertions(+), 51 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 02edc84..025f53a 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -130,9 +130,9 @@ whitespace-chunk =
     / line-comment
     / block-comment
 
-whitespace = *whitespace-chunk
+whsp = *whitespace-chunk
 
-nonempty-whitespace = 1*whitespace-chunk
+whsp1 = 1*whitespace-chunk
 
 ; Uppercase or lowercase ASCII letter
 ALPHA = %x41-5A / %x61-7A
@@ -318,7 +318,7 @@ integer-literal = ( "+" / "-" ) natural-literal
 
 ; The implementation should recognize reserved names for builtins and treat them as special
 ; values instead of variables.
-identifier = any-label [ whitespace "@" whitespace natural-literal ]
+identifier = any-label [ whsp "@" whsp natural-literal ]
 
 ; Printable characters other than " ()[]{}<>/\,"
 ;
@@ -445,7 +445,7 @@ sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
 
 http =
     http-raw
-    [ whitespace using nonempty-whitespace (import-hashed / "(" whitespace import-hashed whitespace ")") ]
+    [ whsp using whsp1 (import-hashed / "(" whsp import-hashed whsp ")") ]
 
 ; Dhall supports unquoted environment variables that are Bash-compliant or
 ; quoted environment variables that are POSIX-compliant
@@ -515,12 +515,12 @@ import-type = missing / local / http / env
 
 hash = %x73.68.61.32.35.36.3a 64HEXDIG  ; "sha256:XXX...XXX"
 
-import-hashed = import-type [ whitespace hash ]
+import-hashed = import-type [ whsp hash ]
 
 ; "http://example.com"
 ; "./foo/bar"
 ; "env:FOO"
-import = import-hashed [ whitespace as nonempty-whitespace Text ]
+import = import-hashed [ whsp as whsp1 Text ]
 
 ; NOTE: Every rule past this point should only reference rules that end with
 ; whitespace.  This ensures consistent handling of whitespace in the absence of
@@ -543,58 +543,58 @@ expression =
     / annotated-expression
 
 ; "\(x : a) -> b"
-lambda-expression = lambda whitespace "(" whitespace unreserved-label whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression
+lambda-expression = lambda whsp "(" whsp unreserved-label whsp ":" whsp1 expression ")" whsp arrow whsp expression
 
 ; "if a then b else c"
-ifthenelse-expression = if nonempty-whitespace expression then nonempty-whitespace expression else nonempty-whitespace expression
+ifthenelse-expression = if whsp1 expression then whsp1 expression else 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 nonempty-whitespace expression
-let-binding = let nonempty-whitespace unreserved-label whitespace [ ":" nonempty-whitespace expression ] "=" whitespace expression
+let-expression = 1*let-binding in whsp1 expression
+let-binding = let whsp1 unreserved-label whsp [ ":" whsp1 expression ] "=" whsp expression
 
 ; "forall (x : a) -> b"
-forall-expression = forall whitespace "(" whitespace unreserved-label whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression
+forall-expression = forall whsp "(" whsp unreserved-label whsp ":" whsp1 expression ")" whsp arrow whsp expression
 
 ; "a -> b"
-arrow-expression = operator-expression arrow whitespace expression
+arrow-expression = operator-expression arrow whsp expression
 
 ; "merge e1 e2 : t"
 ; "merge e1 e2"
-merge-expression = merge nonempty-whitespace import-expression whitespace import-expression whitespace [ ":" nonempty-whitespace application-expression ]
+merge-expression = merge whsp1 import-expression whsp import-expression whsp [ ":" whsp1 application-expression ]
 
 ; "[]  : List     t"
 ; "[]  : Optional t"
 ; "[x] : Optional t"
-empty-list-or-optional = "[" whitespace (empty-collection / non-empty-optional)
-empty-collection = "]" whitespace ":" nonempty-whitespace (List whitespace / Optional whitespace) import-expression whitespace
-non-empty-optional = expression "]" whitespace ":" nonempty-whitespace Optional whitespace import-expression whitespace
+empty-list-or-optional = "[" whsp (empty-collection / non-empty-optional)
+empty-collection = "]" whsp ":" whsp1 (List whsp / Optional whsp) import-expression whsp
+non-empty-optional = expression "]" whsp ":" whsp1 Optional whsp import-expression whsp
 
 ; "x : t"
-annotated-expression = operator-expression [ ":" nonempty-whitespace expression ]
+annotated-expression = operator-expression [ ":" whsp1 expression ]
 
 
 operator-expression = import-alt-expression
 
-import-alt-expression    = or-expression            *("?" nonempty-whitespace    or-expression)
-or-expression            = plus-expression          *("||" whitespace            plus-expression         )
-plus-expression          = text-append-expression   *("+" nonempty-whitespace          text-append-expression  )
-text-append-expression   = list-append-expression   *("++" whitespace   list-append-expression  )
-list-append-expression   = and-expression           *("#" whitespace   and-expression          )
-and-expression           = combine-expression       *("&&" whitespace           combine-expression      )
-combine-expression       = prefer-expression        *(combine whitespace       prefer-expression       )
-prefer-expression        = combine-types-expression *(prefer whitespace        combine-types-expression)
-combine-types-expression = times-expression         *(combine-types whitespace times-expression        )
-times-expression         = equal-expression         *("*" whitespace         equal-expression        )
-equal-expression         = not-equal-expression     *("==" whitespace  not-equal-expression    )
-not-equal-expression     = application-expression   *("!=" whitespace     application-expression  )
+import-alt-expression    = or-expression            *("?" whsp1    or-expression)
+or-expression            = plus-expression          *("||" whsp            plus-expression         )
+plus-expression          = text-append-expression   *("+" whsp1          text-append-expression  )
+text-append-expression   = list-append-expression   *("++" whsp   list-append-expression  )
+list-append-expression   = and-expression           *("#" whsp   and-expression          )
+and-expression           = combine-expression       *("&&" whsp           combine-expression      )
+combine-expression       = prefer-expression        *(combine whsp       prefer-expression       )
+prefer-expression        = combine-types-expression *(prefer whsp        combine-types-expression)
+combine-types-expression = times-expression         *(combine-types whsp times-expression        )
+times-expression         = equal-expression         *("*" whsp         equal-expression        )
+equal-expression         = not-equal-expression     *("==" whsp  not-equal-expression    )
+not-equal-expression     = application-expression   *("!=" whsp     application-expression  )
 
 ; Import expressions need to be separated by some whitespace, otherwise there
 ; would be ambiguity: `./ab` could be interpreted as "import the file `./ab`",
 ; or "apply the import `./a` to label `b`"
 application-expression =
-    import-expression *(nonempty-whitespace import-expression) whitespace
+    import-expression *(whsp1 import-expression) whsp
 
 import-expression =
       import
@@ -607,17 +607,17 @@ import-expression =
 ; can't tell from parsing just the period whether "foo." will become "foo.bar"
 ; (i.e. accessing field `bar` of the record `foo`) or `foo./bar` (i.e. applying
 ; the function `foo` to the relative path `./bar`)
-selector-expression = primitive-expression *(whitespace "." whitespace selector)
+selector-expression = primitive-expression *(whsp "." whsp selector)
 
 selector = any-label / labels
 
-labels = "{" whitespace [ any-label whitespace *("," whitespace any-label whitespace) ] "}"
+labels = "{" whsp [ any-label whsp *("," whsp any-label whsp) ] "}"
 
 
 primitive-expression =
       literal-expression
-    / "{" whitespace record-type-or-literal "}"
-    / "<" whitespace union-type-or-literal ">"
+    / "{" whsp record-type-or-literal "}"
+    / "<" whsp union-type-or-literal ">"
     / non-empty-list-literal
     / parenthesized-expression
 
@@ -656,14 +656,14 @@ record-type-or-literal =
       empty-record-literal
     / non-empty-record-type-or-literal
     / empty-record-type
-empty-record-literal = "=" whitespace
+empty-record-literal = "=" whsp
 empty-record-type = ""
 non-empty-record-type-or-literal =
-    any-label whitespace (non-empty-record-literal / non-empty-record-type)
-non-empty-record-type    = ":" nonempty-whitespace expression *("," whitespace record-type-entry)
-record-type-entry = any-label whitespace ":" nonempty-whitespace expression
-non-empty-record-literal = "=" whitespace expression *("," whitespace record-literal-entry)
-record-literal-entry = any-label whitespace "=" whitespace expression
+    any-label whsp (non-empty-record-literal / non-empty-record-type)
+non-empty-record-type    = ":" whsp1 expression *("," whsp record-type-entry)
+record-type-entry = any-label whsp ":" whsp1 expression
+non-empty-record-literal = "=" whsp expression *("," whsp record-literal-entry)
+record-literal-entry = any-label whsp "=" whsp expression
 
 ; "< Foo : Integer | Bar : Bool >"
 ; "< Foo : Integer | Bar = True >"
@@ -672,21 +672,21 @@ union-type-or-literal =
     / empty-union-type
 empty-union-type = ""
 non-empty-union-type-or-literal =
-    any-label whitespace
-    ( "=" whitespace expression union-type-entries
-    / ":" nonempty-whitespace expression [ "|" whitespace non-empty-union-type-or-literal ]
+    any-label whsp
+    ( "=" whsp expression union-type-entries
+    / ":" whsp1 expression [ "|" whsp non-empty-union-type-or-literal ]
     )
-union-type-entries = *("|" whitespace union-type-entry)
-union-type-entry = any-label whitespace ":" nonempty-whitespace expression
+union-type-entries = *("|" whsp union-type-entry)
+union-type-entry = any-label whsp ":" whsp1 expression
 
 ; "[1, 2, 3]"
 ; `empty-list-or-optional` handles empty lists
-non-empty-list-literal = "[" whitespace expression *("," whitespace expression) "]"
+non-empty-list-literal = "[" whsp expression *("," whsp expression) "]"
 
 ; "( e )"
-parenthesized-expression = "(" whitespace expression ")"
+parenthesized-expression = "(" whsp expression ")"
 
 
 ; All expressions end with trailing whitespace.  This just adds a final
 ; whitespace prefix for the top-level of the program
-complete-expression = whitespace expression
+complete-expression = whsp expression
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.2.3


From ecc39e26a7cf211a5312da468e11f828917e669d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 16:46:39 +0200
Subject: Remove trailing whitespace from expression rules

---
 dhall_parser/src/dhall.abnf | 66 +++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 32 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 025f53a..640a422 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -543,58 +543,60 @@ expression =
     / annotated-expression
 
 ; "\(x : a) -> b"
-lambda-expression = lambda whsp "(" whsp unreserved-label whsp ":" whsp1 expression ")" whsp arrow whsp expression
+lambda-expression = lambda whsp "(" whsp unreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
 
 ; "if a then b else c"
-ifthenelse-expression = if whsp1 expression then whsp1 expression else whsp1 expression
+ifthenelse-expression = 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"
 let-expression = 1*let-binding in whsp1 expression
-let-binding = let whsp1 unreserved-label whsp [ ":" whsp1 expression ] "=" whsp expression
+let-binding = let whsp1 unreserved-label whsp [ ":" whsp1 expression whsp ] "=" whsp expression whsp
 
 ; "forall (x : a) -> b"
-forall-expression = forall whsp "(" whsp unreserved-label whsp ":" whsp1 expression ")" whsp arrow whsp expression
+forall-expression = forall whsp "(" whsp unreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
 
 ; "a -> b"
-arrow-expression = operator-expression arrow whsp expression
+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 ]
+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 whsp / Optional whsp) import-expression whsp
-non-empty-optional = expression "]" whsp ":" whsp1 Optional whsp import-expression whsp
+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 [ ":" whsp1 expression ]
+annotated-expression = operator-expression [ whsp ":" whsp1 expression ]
 
 
 operator-expression = import-alt-expression
 
-import-alt-expression    = or-expression            *("?" whsp1    or-expression)
-or-expression            = plus-expression          *("||" whsp            plus-expression         )
-plus-expression          = text-append-expression   *("+" whsp1          text-append-expression  )
-text-append-expression   = list-append-expression   *("++" whsp   list-append-expression  )
-list-append-expression   = and-expression           *("#" whsp   and-expression          )
-and-expression           = combine-expression       *("&&" whsp           combine-expression      )
-combine-expression       = prefer-expression        *(combine whsp       prefer-expression       )
-prefer-expression        = combine-types-expression *(prefer whsp        combine-types-expression)
-combine-types-expression = times-expression         *(combine-types whsp times-expression        )
-times-expression         = equal-expression         *("*" whsp         equal-expression        )
-equal-expression         = not-equal-expression     *("==" whsp  not-equal-expression    )
-not-equal-expression     = application-expression   *("!=" whsp     application-expression  )
+; Nonempty-whitespace to disambiguate `http://a/a?a`
+import-alt-expression    = or-expression            *(whsp "?" whsp1 or-expression)
+or-expression            = plus-expression          *(whsp "||" whsp plus-expression)
+; Nonempty-whitespace to disambiguate `f +2`
+plus-expression          = text-append-expression   *(whsp "+" whsp1 text-append-expression)
+text-append-expression   = list-append-expression   *(whsp "++" whsp list-append-expression)
+list-append-expression   = and-expression           *(whsp "#" whsp and-expression)
+and-expression           = combine-expression       *(whsp "&&" whsp combine-expression)
+combine-expression       = prefer-expression        *(whsp combine whsp prefer-expression)
+prefer-expression        = combine-types-expression *(whsp prefer whsp combine-types-expression)
+combine-types-expression = times-expression         *(whsp combine-types whsp times-expression)
+times-expression         = equal-expression         *(whsp "*" whsp equal-expression)
+equal-expression         = not-equal-expression     *(whsp "==" whsp not-equal-expression)
+not-equal-expression     = application-expression   *(whsp "!=" whsp application-expression)
 
 ; Import expressions need to be separated by some whitespace, otherwise there
 ; would be ambiguity: `./ab` could be interpreted as "import the file `./ab`",
 ; or "apply the import `./a` to label `b`"
 application-expression =
-    import-expression *(whsp1 import-expression) whsp
+    import-expression *(whsp1 import-expression)
 
 import-expression =
       import
@@ -660,10 +662,10 @@ empty-record-literal = "=" whsp
 empty-record-type = ""
 non-empty-record-type-or-literal =
     any-label whsp (non-empty-record-literal / non-empty-record-type)
-non-empty-record-type    = ":" whsp1 expression *("," whsp record-type-entry)
-record-type-entry = any-label whsp ":" whsp1 expression
-non-empty-record-literal = "=" whsp expression *("," whsp record-literal-entry)
-record-literal-entry = any-label whsp "=" whsp expression
+non-empty-record-type    = ":" whsp1 expression whsp *("," whsp record-type-entry)
+record-type-entry = any-label whsp ":" whsp1 expression whsp
+non-empty-record-literal = "=" whsp expression whsp *("," whsp record-literal-entry)
+record-literal-entry = any-label whsp "=" whsp expression whsp
 
 ; "< Foo : Integer | Bar : Bool >"
 ; "< Foo : Integer | Bar = True >"
@@ -673,20 +675,20 @@ union-type-or-literal =
 empty-union-type = ""
 non-empty-union-type-or-literal =
     any-label whsp
-    ( "=" whsp expression union-type-entries
-    / ":" whsp1 expression [ "|" whsp non-empty-union-type-or-literal ]
+    ( "=" whsp expression whsp union-type-entries
+    / ":" whsp1 expression whsp [ "|" whsp non-empty-union-type-or-literal ]
     )
 union-type-entries = *("|" whsp union-type-entry)
-union-type-entry = any-label whsp ":" whsp1 expression
+union-type-entry = any-label whsp ":" whsp1 expression whsp
 
 ; "[1, 2, 3]"
 ; `empty-list-or-optional` handles empty lists
-non-empty-list-literal = "[" whsp expression *("," whsp expression) "]"
+non-empty-list-literal = "[" whsp expression whsp *("," whsp expression whsp) "]"
 
 ; "( e )"
-parenthesized-expression = "(" whsp expression ")"
+parenthesized-expression = "(" whsp expression whsp ")"
 
 
 ; All expressions end with trailing whitespace.  This just adds a final
 ; whitespace prefix for the top-level of the program
-complete-expression = whsp expression
+complete-expression = whsp expression whsp
-- 
cgit v1.2.3


From 2930da578e6a7847a33aee0d7145552b299e783d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 17:23:36 +0200
Subject: rename

---
 dhall_parser/src/dhall.abnf | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 640a422..8964f44 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -170,11 +170,11 @@ quoted-label = 1*quoted-label-char
 ; for code obfuscation
 label = ("`" quoted-label "`" / simple-label)
 
-; An unreserved-label cannot not be any of the reserved identifiers for builtins (unless quoted).
+; A nonreserved-label cannot not be any of the reserved identifiers for builtins (unless quoted).
 ; Their list can be found in semantics.md. This is not enforced by the grammar but
 ; should be checked by implementations. The only place where this restriction applies
 ; is bound variables.
-unreserved-label = label
+nonreserved-label = label
 
 ; An any-label is allowed to be one of the reserved identifiers.
 any-label = label
@@ -543,7 +543,7 @@ expression =
     / annotated-expression
 
 ; "\(x : a) -> b"
-lambda-expression = lambda whsp "(" whsp unreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
+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
@@ -552,10 +552,10 @@ ifthenelse-expression = if whsp1 expression whsp then whsp1 expression whsp else
 ; "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 unreserved-label whsp [ ":" whsp1 expression whsp ] "=" whsp expression whsp
+let-binding = let whsp1 nonreserved-label whsp [ ":" whsp1 expression whsp ] "=" whsp expression whsp
 
 ; "forall (x : a) -> b"
-forall-expression = forall whsp "(" whsp unreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
+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
-- 
cgit v1.2.3


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_parser/src/dhall.abnf            | 64 +++++++++++++++-------------------
 dhall_parser/src/dhall.pest.visibility | 22 ++++--------
 2 files changed, 36 insertions(+), 50 deletions(-)

(limited to 'dhall_parser')

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.2.3


From f385e9dabfe3d923a841dc6d99542683cbbbb77a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 19:46:17 +0200
Subject: Import many trivial changes from upstream

---
 dhall_parser/src/dhall.abnf | 90 ++++++++++++++++++++++-----------------------
 1 file changed, 44 insertions(+), 46 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 2fad4d4..ca54215 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -132,6 +132,7 @@ whitespace-chunk =
 
 whsp = *whitespace-chunk
 
+; nonempty whitespace
 whsp1 = 1*whitespace-chunk
 
 ; Uppercase or lowercase ASCII letter
@@ -142,19 +143,13 @@ DIGIT = %x30-39  ; 0-9
 
 HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
 
-; A simple label cannot be one of the following reserved keywords:
-;
-; * if
-; * then
-; * else
-; * let
-; * in
-; * as
-; * using
-; * merge
-; * missing
-; * Infinity
-; * Some
+; A simple label cannot be one of the reserved keywords
+; listed in the `keyword` rule.
+; A PEG parser could use negative lookahead to
+; enforce this, e.g. as follows:
+; simple-label =
+;       keyword 1*simple-label-next-char
+;     / !keyword (simple-label-first-char *simple-label-next-char)
 simple-label-first-char = ALPHA / "_"
 simple-label-next-char = ALPHA / DIGIT / "-" / "/" / "_"
 simple-label = simple-label-first-char *simple-label-next-char
@@ -174,6 +169,7 @@ label = ("`" quoted-label "`" / simple-label)
 ; Their list can be found in semantics.md. This is not enforced by the grammar but
 ; should be checked by implementations. The only place where this restriction applies
 ; is bound variables.
+; A PEG parser could use negative lookahead to avoid parsing those identifiers.
 nonreserved-label = label
 
 ; An any-label is allowed to be one of the reserved identifiers.
@@ -216,8 +212,8 @@ any-label = label
 ; > "\uD834\uDD1E".
 double-quote-chunk =
       interpolation
-      ; '\'
-    / %x5C double-quote-escaped 
+      ; '\'    Beginning of escape sequence
+    / %x5C double-quote-escaped
     / double-quote-char
 
 double-quote-escaped =
@@ -273,7 +269,6 @@ single-quote-char =
 
 single-quote-literal = "''" end-of-line single-quote-continue
 
-; Interpolation
 interpolation = "${" complete-expression "}"
 
 text-literal = (double-quote-literal / single-quote-literal)
@@ -281,25 +276,25 @@ text-literal = (double-quote-literal / single-quote-literal)
 ; RFC 5234 interprets string literals as case-insensitive and recommends using
 ; hex instead for case-sensitive strings
 ;
-; If you don't feel like reading hex, these are all the same as the rule name,
-; except without the '' ending.
+; If you don't feel like reading hex, these are all the same as the rule name.
 ; Keywords that should never be parsed as identifiers
-if                = %x69.66
-then              = %x74.68.65.6e
-else              = %x65.6c.73.65
-let               = %x6c.65.74
-in                = %x69.6e
-as                = %x61.73
-using             = %x75.73.69.6e.67
-merge             = %x6d.65.72.67.65
-missing           = %x6d.69.73.73.69.6e.67
-Infinity          = %x49.6e.66.69.6e.69.74.79
+if                    = %x69.66
+then                  = %x74.68.65.6e
+else                  = %x65.6c.73.65
+let                   = %x6c.65.74
+in                    = %x69.6e
+as                    = %x61.73
+using                 = %x75.73.69.6e.67
+merge                 = %x6d.65.72.67.65
+missing               = %x6d.69.73.73.69.6e.67
+Infinity              = %x49.6e.66.69.6e.69.74.79
+NaN                   = %x4e.61.4e
+Some                  = %x53.6f.6d.65
+
 ; Reserved identifiers, only needed for some special cases of parsing
 Optional              = %x4f.70.74.69.6f.6e.61.6c
 Text                  = %x54.65.78.74
 List                  = %x4c.69.73.74
-NaN               = %x4e.61.4e
-Some              = %x53.6f.6d.65
 
 combine       = %x2227 / "/\"
 combine-types = %x2A53 / "//\\"
@@ -363,6 +358,8 @@ quoted-path-component = 1*quoted-path-character
 
 path-component = "/" ( unquoted-path-component / %x22 quoted-path-component %x22 )
 
+; The last path-component matched by this rule is referred to as "file" in the semantics,
+; and the other path-components as "directory".
 path = 1*path-component
 
 local =
@@ -513,7 +510,7 @@ posix-environment-variable-character =
 
 import-type = missing / local / http / env
 
-hash = %x73.68.61.32.35.36.3a 64HEXDIG  ; "sha256:XXX...XXX"
+hash = %x73.68.61.32.35.36.3a 64HEXDIG ; "sha256:XXX...XXX"
 
 import-hashed = import-type [ whsp hash ]
 
@@ -522,12 +519,6 @@ import-hashed = import-type [ whsp hash ]
 ; "env:FOO"
 import = import-hashed [ whsp as whsp1 Text ]
 
-; NOTE: Every rule past this point should only reference rules that end with
-; whitespace.  This ensures consistent handling of whitespace in the absence of
-; a separate lexing step.
-; The exception is the rules ending in , which should _not_ end in whitespace.
-; This is important to avoid the need for sequential backtracking in application-expression.
-
 expression =
     ; "\(x : a) -> b"
       lambda whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
@@ -544,6 +535,7 @@ expression =
     / forall whsp "(" whsp nonreserved-label whsp ":" whsp1 expression whsp ")" whsp arrow whsp expression
     
     ; "a -> b"
+    ;
     ; NOTE: Backtrack if parsing this alternative fails
     / operator-expression whsp arrow whsp expression
     
@@ -554,6 +546,7 @@ 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
@@ -562,11 +555,17 @@ expression =
     ; "x : t"
     / annotated-expression
 
-; "x : t"
+; Nonempty-whitespace to disambiguate `env:VARIABLE` from type annotations
 annotated-expression = operator-expression [ whsp ":" whsp1 expression ]
 
+; "let x = e1"
 let-binding = let whsp1 nonreserved-label whsp [ ":" whsp1 expression whsp ] "=" whsp expression whsp
+
+; "]  : List     t"
+; "]  : Optional t"
 empty-collection = "]" whsp ":" whsp1 (List / Optional) whsp import-expression
+
+; "x] : Optional t"
 non-empty-optional = expression whsp "]" whsp ":" whsp1 Optional whsp import-expression
 
 operator-expression = import-alt-expression
@@ -592,14 +591,13 @@ not-equal-expression     = application-expression   *(whsp "!=" whsp application
 application-expression =
     import-expression *(whsp1 import-expression)
 
-import-expression =
-      import
-    / selector-expression
+import-expression = import / selector-expression
 
 ; `record.field` extracts one field of a record
+;
 ; `record.{ field0, field1, field2 }` projects out several fields of a record
 ;
-; NOTE: Backtrack when parsing the `*(dot ...)`.  The reason why is that you
+; NOTE: Backtrack when parsing the `*("." ...)`.  The reason why is that you
 ; can't tell from parsing just the period whether "foo." will become "foo.bar"
 ; (i.e. accessing field `bar` of the record `foo`) or `foo./bar` (i.e. applying
 ; the function `foo` to the relative path `./bar`)
@@ -646,14 +644,13 @@ literal-expression =
 minus-infinity-literal = "-" Infinity
 plus-infinity-literal = Infinity
 
-; "{ foo = 1      , bar = True }"
-; "{ foo : Integer, bar : Bool }"
 record-type-or-literal =
       empty-record-literal
     / non-empty-record-type-or-literal
     / empty-record-type
 empty-record-literal = "=" whsp
 empty-record-type = ""
+
 non-empty-record-type-or-literal =
     any-label whsp (non-empty-record-literal / non-empty-record-type)
 non-empty-record-type    = ":" whsp1 expression whsp *("," whsp record-type-entry)
@@ -666,7 +663,9 @@ record-literal-entry = any-label whsp "=" whsp expression whsp
 union-type-or-literal =
       non-empty-union-type-or-literal
     / empty-union-type
+
 empty-union-type = ""
+
 non-empty-union-type-or-literal =
     any-label whsp
     ( "=" whsp expression whsp union-type-entries
@@ -683,6 +682,5 @@ non-empty-list-literal = "[" whsp expression whsp *("," whsp expression whsp) "]
 parenthesized-expression = "(" whsp expression whsp ")"
 
 
-; All expressions end with trailing whitespace.  This just adds a final
-; whitespace prefix for the top-level of the program
+; This just adds surrounding whitespace for the top-level of the program
 complete-expression = whsp expression whsp
-- 
cgit v1.2.3


From 2ef0951c45e3c9c87990ab7e334059aa9b21f540 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 19:51:12 +0200
Subject: Tweak double literals

---
 dhall_parser/src/dhall.abnf | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index ca54215..15fd898 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -305,7 +305,20 @@ arrow         = %x2192 / "->"
 
 exponent = "e" [ "+" / "-" ] 1*DIGIT
 
-double-literal = [ "+" / "-" ] 1*DIGIT ( "." 1*DIGIT [ exponent ] / exponent)
+numeric-double-literal = [ "+" / "-" ] 1*DIGIT ( "." 1*DIGIT [ exponent ] / exponent)
+
+minus-infinity-literal = "-" Infinity
+plus-infinity-literal = Infinity
+
+double-literal =
+    ; "2.0"
+      numeric-double-literal
+    ; "-Infinity"
+    / minus-infinity-literal
+    ; "Infinity"
+    / plus-infinity-literal
+    ; "NaN"
+    / NaN
 
 natural-literal = 1*DIGIT
 
@@ -627,13 +640,6 @@ literal-expression =
     ; "+2"
     / integer-literal
     
-    ; "-Infinity"
-    / minus-infinity-literal
-    ; "Infinity"
-    / plus-infinity-literal
-    ; "NaN"
-    / NaN
-    
     ; '"ABC"'
     / text-literal
     
-- 
cgit v1.2.3


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_parser/src/dhall.abnf            | 16 ++++------------
 dhall_parser/src/dhall.pest.visibility |  3 +--
 2 files changed, 5 insertions(+), 14 deletions(-)

(limited to 'dhall_parser')

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.2.3


From 7b8c64a754bbd2f9c55cf8992d5bcc8c7a460327 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 20:18:19 +0200
Subject: Whitespace

---
 dhall_parser/src/dhall.abnf | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 52d5b91..9456036 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -620,7 +620,8 @@ selector = any-label / labels
 
 labels = "{" whsp [ any-label whsp *("," whsp any-label whsp) ] "}"
 
-
+; NOTE: Backtrack when parsing the first three alternatives (i.e. the numeric
+; literals).  This is because they share leading characters in common
 primitive-expression =
     ; "2.0"
       double-literal
@@ -634,27 +635,27 @@ primitive-expression =
     ; '"ABC"'
     / text-literal
     
+    / "{" whsp record-type-or-literal whsp "}"
+    / "<" whsp union-type-or-literal whsp ">"
+    / non-empty-list-literal
     ; "x"
     ; "x@2"
     / identifier
-    / "{" whsp record-type-or-literal "}"
-    / "<" whsp union-type-or-literal ">"
-    / non-empty-list-literal
-    / parenthesized-expression
+    / "(" whsp expression whsp ")"
 
 record-type-or-literal =
       empty-record-literal
     / non-empty-record-type-or-literal
     / empty-record-type
-empty-record-literal = "=" whsp
+empty-record-literal = "="
 empty-record-type = ""
 
 non-empty-record-type-or-literal =
     any-label whsp (non-empty-record-literal / non-empty-record-type)
-non-empty-record-type    = ":" whsp1 expression whsp *("," whsp record-type-entry)
-record-type-entry = any-label whsp ":" whsp1 expression whsp
-non-empty-record-literal = "=" whsp expression whsp *("," whsp record-literal-entry)
-record-literal-entry = any-label whsp "=" whsp expression whsp
+non-empty-record-type    = ":" whsp1 expression *(whsp "," whsp record-type-entry)
+record-type-entry = any-label whsp ":" whsp1 expression
+non-empty-record-literal = "=" whsp expression *(whsp "," whsp record-literal-entry)
+record-literal-entry = any-label whsp "=" whsp expression
 
 ; "< Foo : Integer | Bar : Bool >"
 ; "< Foo : Integer | Bar = True >"
@@ -666,19 +667,16 @@ empty-union-type = ""
 
 non-empty-union-type-or-literal =
     any-label whsp
-    ( "=" whsp expression whsp union-type-entries
-    / ":" whsp1 expression whsp [ "|" whsp non-empty-union-type-or-literal ]
+    ( "=" whsp expression union-type-entries
+    / ":" whsp1 expression [ whsp "|" whsp non-empty-union-type-or-literal ]
     )
-union-type-entries = *("|" whsp union-type-entry)
-union-type-entry = any-label whsp ":" whsp1 expression whsp
+union-type-entries = *(whsp "|" whsp union-type-entry)
+union-type-entry = any-label whsp ":" whsp1 expression
 
 ; "[1, 2, 3]"
 ; `empty-list-or-optional` handles empty lists
 non-empty-list-literal = "[" whsp expression whsp *("," whsp expression whsp) "]"
 
-; "( e )"
-parenthesized-expression = "(" whsp expression whsp ")"
-
 
 ; This just adds surrounding whitespace for the top-level of the program
 complete-expression = whsp expression whsp
-- 
cgit v1.2.3


From ebbd660008dc783ae6c8bc57ca764309ea463a5e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 20:20:43 +0200
Subject: Import more trivial changes from upstream

---
 dhall_parser/src/dhall.abnf | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 9456036..0f07a20 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -635,30 +635,43 @@ primitive-expression =
     ; '"ABC"'
     / text-literal
     
+    ; "{ foo = 1      , bar = True }"
+    ; "{ foo : Integer, bar : Bool }"
     / "{" whsp record-type-or-literal whsp "}"
+    
+    ; "< Foo : Integer | Bar : Bool >"
+    ; "< Foo : Integer | Bar = True | Baz : Bool >"
+    ; "< Foo | Bar : Bool >"
     / "<" whsp union-type-or-literal whsp ">"
+    
+    ; "[1, 2, 3]"
+    ; `empty-collection` handles empty lists
     / non-empty-list-literal
+    
     ; "x"
     ; "x@2"
     / identifier
-    / "(" whsp expression whsp ")"
+    
+    ; "( e )"
+    / "(" complete-expression ")"
 
 record-type-or-literal =
       empty-record-literal
     / non-empty-record-type-or-literal
     / empty-record-type
+
 empty-record-literal = "="
 empty-record-type = ""
 
 non-empty-record-type-or-literal =
     any-label whsp (non-empty-record-literal / non-empty-record-type)
-non-empty-record-type    = ":" whsp1 expression *(whsp "," whsp record-type-entry)
+
+non-empty-record-type = ":" whsp1 expression *(whsp "," whsp record-type-entry)
 record-type-entry = any-label whsp ":" whsp1 expression
+
 non-empty-record-literal = "=" whsp expression *(whsp "," whsp record-literal-entry)
 record-literal-entry = any-label whsp "=" whsp expression
 
-; "< Foo : Integer | Bar : Bool >"
-; "< Foo : Integer | Bar = True >"
 union-type-or-literal =
       non-empty-union-type-or-literal
     / empty-union-type
-- 
cgit v1.2.3


From 08596e55a3e71f2fd636494aaa232e1cf476e4ac Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 21:35:11 +0200
Subject: Handle Some as in upstream grammar

---
 dhall_parser/src/dhall.abnf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 0f07a20..4aa3fec 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -602,7 +602,7 @@ not-equal-expression     = application-expression   *(whsp "!=" whsp application
 ; would be ambiguity: `./ab` could be interpreted as "import the file `./ab`",
 ; or "apply the import `./a` to label `b`"
 application-expression =
-    import-expression *(whsp1 import-expression)
+    [ Some whsp1 ] import-expression *(whsp1 import-expression)
 
 import-expression = import / selector-expression
 
-- 
cgit v1.2.3


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_parser/build.rs                  | 7 -------
 dhall_parser/src/dhall.abnf            | 9 +++++++++
 dhall_parser/src/dhall.pest.visibility | 1 +
 3 files changed, 10 insertions(+), 7 deletions(-)

(limited to 'dhall_parser')

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.2.3


From e7a58d09748bd333f755a06090f378e31dc6617a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 4 Apr 2019 22:28:00 +0200
Subject: Import union rules from upstream grammar

---
 dhall_parser/src/dhall.abnf | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'dhall_parser')

diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index 01ec6d8..7ad0b24 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -688,17 +688,18 @@ union-type-or-literal =
 empty-union-type = ""
 
 non-empty-union-type-or-literal =
-    any-label whsp
-    ( "=" whsp expression union-type-entries
-    / ":" whsp1 expression [ whsp "|" whsp non-empty-union-type-or-literal ]
-    )
-union-type-entries = *(whsp "|" whsp union-type-entry)
+    any-label [ whsp ( union-literal-variant-value / union-type-or-literal-variant-type) ]
+
+; = True | ...
+union-literal-variant-value = "=" whsp expression *(whsp "|" whsp union-type-entry)
 union-type-entry = any-label whsp ":" whsp1 expression
 
-; "[1, 2, 3]"
-; `empty-list-or-optional` handles empty lists
-non-empty-list-literal = "[" whsp expression whsp *("," whsp expression whsp) "]"
+; : Integer | ...
+; | ...
+union-type-or-literal-variant-type = [ ":" whsp1 expression ] [ whsp "|" whsp non-empty-union-type-or-literal ]
 
 
+non-empty-list-literal = "[" whsp expression whsp *("," whsp expression whsp) "]"
+
 ; This just adds surrounding whitespace for the top-level of the program
 complete-expression = whsp expression whsp
-- 
cgit v1.2.3


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_parser/src/dhall.abnf            | 9 ++++-----
 dhall_parser/src/dhall.pest.visibility | 3 +--
 2 files changed, 5 insertions(+), 7 deletions(-)

(limited to 'dhall_parser')

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.2.3


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')

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.2.3