Write a custom map type that allows duplicates

1 files changed, 14 insertions, 23 deletions

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 276510e..c847b29 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -7,6 +7,7 @@ use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
 
+use crate::map::DupTreeMap;
 use crate::ExprF::*;
 use crate::*;
 
@@ -886,33 +887,29 @@ make_parser! {
     ));
 
     rule!(empty_record_literal<ParsedSubExpr> as expression; span;
-        captured_str!(_) => spanned(span, RecordLit(Vec::new()))
+        captured_str!(_) => spanned(span, RecordLit(Default::default()))
     );
 
     rule!(empty_record_type<ParsedSubExpr> as expression; span;
-        captured_str!(_) => spanned(span, RecordType(Vec::new()))
+        captured_str!(_) => spanned(span, RecordType(Default::default()))
     );
 
     rule!(non_empty_record_type_or_literal<ParsedSubExpr> as expression; span;
           children!(
         [label(first_label), non_empty_record_type(rest)] => {
             let (first_expr, mut map) = rest;
-            map.push((first_label, first_expr));
-            // Sort until we stop using binary decode for parser tests
-            map.sort_by(|(l1, _), (l2, _)| l1.cmp(l2));
+            map.insert(first_label, first_expr);
             spanned(span, RecordType(map))
         },
         [label(first_label), non_empty_record_literal(rest)] => {
             let (first_expr, mut map) = rest;
-            map.push((first_label, first_expr));
-            // Sort until we stop using binary decode for parser tests
-            map.sort_by(|(l1, _), (l2, _)| l1.cmp(l2));
+            map.insert(first_label, first_expr);
             spanned(span, RecordLit(map))
         },
     ));
 
     rule!(non_empty_record_type
-          <(ParsedSubExpr, Vec<(Label, ParsedSubExpr)>)>; children!(
+          <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!(
         [expression(expr), record_type_entry(entries)..] => {
             (expr, entries.collect())
         }
@@ -923,7 +920,7 @@ make_parser! {
     ));
 
     rule!(non_empty_record_literal
-          <(ParsedSubExpr, Vec<(Label, ParsedSubExpr)>)>; children!(
+          <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!(
         [expression(expr), record_literal_entry(entries)..] => {
             (expr, entries.collect())
         }
@@ -935,18 +932,12 @@ make_parser! {
 
     rule!(union_type_or_literal<ParsedSubExpr> as expression; span; children!(
         [empty_union_type(_)] => {
-            spanned(span, UnionType(Vec::new()))
+            spanned(span, UnionType(Default::default()))
         },
         [non_empty_union_type_or_literal((Some((l, e)), entries))] => {
-            let mut entries = entries;
-            // Sort until we stop using binary decode for parser tests
-            entries.sort_by(|(l1, _), (l2, _)| l1.cmp(l2));
             spanned(span, UnionLit(l, e, entries))
         },
         [non_empty_union_type_or_literal((None, entries))] => {
-            let mut entries = entries;
-            // Sort until we stop using binary decode for parser tests
-            entries.sort_by(|(l1, _), (l2, _)| l1.cmp(l2));
             spanned(span, UnionType(entries))
         },
     ));
@@ -955,20 +946,20 @@ make_parser! {
 
     rule!(non_empty_union_type_or_literal
           <(Option<(Label, ParsedSubExpr)>,
-            Vec<(Label, Option<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.push((l, e));
+            entries.insert(l, e);
             (x, entries)
         },
     ));
 
     rule!(union_literal_variant_value
-          <(ParsedSubExpr, Vec<(Label, Option<ParsedSubExpr>)>)>;
+          <(ParsedSubExpr, DupTreeMap<Label, Option<ParsedSubExpr>>)>;
             children!(
         [expression(e), union_type_entry(entries)..] => {
             (e, entries.collect())
@@ -984,19 +975,19 @@ make_parser! {
     rule!(union_type_or_literal_variant_type
           <(Option<ParsedSubExpr>,
             (Option<(Label, ParsedSubExpr)>,
-             Vec<(Label, Option<ParsedSubExpr>)>))>;
+             DupTreeMap<Label, Option<ParsedSubExpr>>))>;
                 children!(
         [expression(e), non_empty_union_type_or_literal(rest)] => {
             (Some(e), rest)
         },
         [expression(e)] => {
-            (Some(e), (None, Vec::new()))
+            (Some(e), (None, Default::default()))
         },
         [non_empty_union_type_or_literal(rest)] => {
             (None, rest)
         },
         [] => {
-            (None, (None, Vec::new()))
+            (None, (None, Default::default()))
         },
     ));