From d248762095908246951b6aa6c211587c6e333c0e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 7 Aug 2019 21:05:01 +0200
Subject: Remove union literals from the language

---
 dhall_syntax/src/core/expr.rs    |  2 --
 dhall_syntax/src/core/visitor.rs |  3 ---
 dhall_syntax/src/parser.rs       | 51 +++-------------------------------------
 dhall_syntax/src/printer.rs      | 10 --------
 4 files changed, 3 insertions(+), 63 deletions(-)

(limited to 'dhall_syntax')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 668ab45..aab4b6a 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -202,8 +202,6 @@ pub enum ExprF<SubExpr, Embed> {
     RecordLit(DupTreeMap<Label, SubExpr>),
     ///  `< k1 : t1, k2 >`
     UnionType(DupTreeMap<Label, Option<SubExpr>>),
-    ///  `< k1 = t1, k2 : t2, k3 >`
-    UnionLit(Label, SubExpr, DupTreeMap<Label, Option<SubExpr>>),
     ///  `merge x y : t`
     Merge(SubExpr, SubExpr, Option<SubExpr>),
     ///  `e.x`
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index b02544f..68ad956 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -141,9 +141,6 @@ where
             RecordType(kts) => RecordType(dupmap(kts, v)?),
             RecordLit(kvs) => RecordLit(dupmap(kvs, v)?),
             UnionType(kts) => UnionType(optdupmap(kts, v)?),
-            UnionLit(k, x, kts) => {
-                UnionLit(k.clone(), v.visit_subexpr(x)?, optdupmap(kts, v)?)
-            }
             Merge(x, y, t) => Merge(
                 v.visit_subexpr(x)?,
                 v.visit_subexpr(y)?,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 8336c74..a7f419a 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -976,67 +976,22 @@ make_parser! {
         [label(name), expression(expr)] => (name, expr)
     ));
 
-    rule!(union_type_or_literal<ParsedSubExpr> as expression; span; children!(
+    rule!(union_type<ParsedSubExpr> as expression; span; children!(
         [empty_union_type(_)] => {
             spanned(span, UnionType(Default::default()))
         },
-        [non_empty_union_type_or_literal((Some((l, e)), entries))] => {
-            spanned(span, UnionLit(l, e, entries))
-        },
-        [non_empty_union_type_or_literal((None, entries))] => {
-            spanned(span, UnionType(entries))
+        [union_type_entry(entries)..] => {
+            spanned(span, UnionType(entries.collect()))
         },
     ));
 
     token_rule!(empty_union_type<()>);
 
-    rule!(non_empty_union_type_or_literal
-          <(Option<(Label, ParsedSubExpr)>,
-            DupTreeMap<Label, Option<ParsedSubExpr>>)>;
-            children!(
-        [label(l), union_literal_variant_value((e, entries))] => {
-            (Some((l, e)), entries)
-        },
-        [label(l), union_type_or_literal_variant_type((e, rest))] => {
-            let (x, mut entries) = rest;
-            entries.insert(l, e);
-            (x, entries)
-        },
-    ));
-
-    rule!(union_literal_variant_value
-          <(ParsedSubExpr, DupTreeMap<Label, Option<ParsedSubExpr>>)>;
-            children!(
-        [expression(e), union_type_entry(entries)..] => {
-            (e, entries.collect())
-        },
-    ));
-
     rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!(
         [label(name), expression(expr)] => (name, Some(expr)),
         [label(name)] => (name, None),
     ));
 
-    // TODO: unary union variants
-    rule!(union_type_or_literal_variant_type
-          <(Option<ParsedSubExpr>,
-            (Option<(Label, ParsedSubExpr)>,
-             DupTreeMap<Label, Option<ParsedSubExpr>>))>;
-                children!(
-        [expression(e), non_empty_union_type_or_literal(rest)] => {
-            (Some(e), rest)
-        },
-        [expression(e)] => {
-            (Some(e), (None, Default::default()))
-        },
-        [non_empty_union_type_or_literal(rest)] => {
-            (None, rest)
-        },
-        [] => {
-            (None, (None, Default::default()))
-        },
-    ));
-
     rule!(non_empty_list_literal<ParsedSubExpr> as expression; span;
           children!(
         [expression(items)..] => spanned(
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 52d3d81..db688bd 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -85,16 +85,6 @@ impl<SE: Display + Clone, E: Display> Display for ExprF<SE, E> {
                 }
                 Ok(())
             })?,
-            UnionLit(a, b, c) => {
-                write!(f, "< {} = {}", a, b)?;
-                for (k, v) in c {
-                    write!(f, " | {}", k)?;
-                    if let Some(v) = v {
-                        write!(f, ": {}", v)?;
-                    }
-                }
-                f.write_str(" >")?
-            }
             Embed(a) => a.fmt(f)?,
         }
         Ok(())
-- 
cgit v1.2.3