Parse record and tuple patterns

fathom/src/surface.rs

@@ -66,7 +66,7 @@ pub struct ItemDef<'arena, Range> {
     /// The label that identifies this definition
     label: (Range, StringId),
     /// Parameter patterns
-    patterns: &'arena [(Pattern<Range>, Option<&'arena Term<'arena, Range>>)],
+    patterns: &'arena [(Pattern<'arena, Range>, Option<&'arena Term<'arena, Range>>)],
     /// An optional type annotation for the defined expression
     // FIXME: raw identifiers in LALRPOP grammars https://github.com/lalrpop/lalrpop/issues/613
     type_: Option<&'arena Term<'arena, Range>>,
@@ -76,7 +76,7 @@ pub struct ItemDef<'arena, Range> {
 
 /// Surface patterns.
 #[derive(Debug, Clone)]
-pub enum Pattern<Range> {
+pub enum Pattern<'arena, Range> {
     /// Named patterns, eg. `x`, `true`, `false`
     Name(Range, StringId),
     /// Placeholder patterns, eg. `_`
@@ -93,8 +93,10 @@ pub enum Pattern<Range> {
     NumberLiteral(Range, StringId),
     /// Boolean literal patterns
     BooleanLiteral(Range, bool),
-    // TODO: Record literal patterns
-    // RecordLiteral(Range, &'arena [((ByteRange, StringId), Pattern<'arena, Range>)]),
+    /// Record literal patterns
+    RecordLiteral(Range, &'arena [PatternField<'arena, Range>]),
+    /// Tuple literal patterns
+    Tuple(Range, &'arena [Pattern<'arena, Range>]),
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -151,14 +153,16 @@ impl<Range> fmt::Display for BinOp<Range> {
     }
 }
 
-impl<Range: Clone> Pattern<Range> {
+impl<'arena, Range: Clone> Pattern<'arena, Range> {
     pub fn range(&self) -> Range {
         match self {
             Pattern::Name(range, _)
             | Pattern::Placeholder(range)
             | Pattern::StringLiteral(range, _)
             | Pattern::NumberLiteral(range, _)
-            | Pattern::BooleanLiteral(range, _) => range.clone(),
+            | Pattern::BooleanLiteral(range, _)
+            | Pattern::RecordLiteral(range, _)
+            | Pattern::Tuple(range, _) => range.clone(),
         }
     }
 }
@@ -181,7 +185,7 @@ pub enum Term<'arena, Range> {
     /// Let expressions.
     Let(
         Range,
-        Pattern<Range>,
+        Pattern<'arena, Range>,
         Option<&'arena Term<'arena, Range>>,
         &'arena Term<'arena, Range>,
         &'arena Term<'arena, Range>,
@@ -197,7 +201,7 @@ pub enum Term<'arena, Range> {
     Match(
         Range,
         &'arena Term<'arena, Range>,
-        &'arena [(Pattern<Range>, Term<'arena, Range>)],
+        &'arena [(Pattern<'arena, Range>, Term<'arena, Range>)],
     ),
     /// The type of types.
     Universe(Range),
@@ -210,13 +214,13 @@ pub enum Term<'arena, Range> {
     /// Dependent function types.
     FunType(
         Range,
-        &'arena [(Pattern<Range>, Option<&'arena Term<'arena, Range>>)],
+        &'arena [(Pattern<'arena, Range>, Option<&'arena Term<'arena, Range>>)],
         &'arena Term<'arena, Range>,
     ),
     /// Function literals.
     FunLiteral(
         Range,
-        &'arena [(Pattern<Range>, Option<&'arena Term<'arena, Range>>)],
+        &'arena [(Pattern<'arena, Range>, Option<&'arena Term<'arena, Range>>)],
         &'arena Term<'arena, Range>,
     ),
     /// Applications.
@@ -373,6 +377,15 @@ pub struct ExprField<'arena, Range> {
     expr: Term<'arena, Range>,
 }
 
+/// A field definition in a record pattern
+#[derive(Debug, Clone)]
+pub struct PatternField<'arena, Range> {
+    /// Label identifying the field
+    label: (Range, StringId),
+    /// The pattern that this field will match
+    pattern: Pattern<'arena, Range>,
+}
+
 /// Messages produced during parsing
 #[derive(Clone, Debug)]
 pub enum ParseMessage {

fathom/src/surface/distillation.rs

@@ -129,15 +129,15 @@ impl<'interner, 'arena, 'env> Context<'interner, 'arena, 'env> {
         Term::NumberLiteral((), number)
     }
 
-    fn check_boolean_pattern(&mut self, boolean: bool) -> Pattern<()> {
+    fn check_boolean_pattern(&mut self, boolean: bool) -> Pattern<'arena, ()> {
         let name = match boolean {
             true => self.interner.borrow_mut().get_or_intern("true"),
             false => self.interner.borrow_mut().get_or_intern("false"),
         };
         Pattern::Name((), name)
     }
 
-    fn check_number_pattern<T: std::fmt::Display>(&mut self, number: T) -> Pattern<()> {
+    fn check_number_pattern<T: std::fmt::Display>(&mut self, number: T) -> Pattern<'arena, ()> {
         let number = self.interner.borrow_mut().get_or_intern(number.to_string());
         Pattern::NumberLiteral((), number)
     }
@@ -146,14 +146,14 @@ impl<'interner, 'arena, 'env> Context<'interner, 'arena, 'env> {
         &mut self,
         number: T,
         style: UIntStyle,
-    ) -> Pattern<()> {
+    ) -> Pattern<'arena, ()> {
         // TODO: Share with check_number_literal_styled
         let string = style.format(number);
         let number = self.interner.borrow_mut().get_or_intern(string);
         Pattern::NumberLiteral((), number)
     }
 
-    fn check_constant_pattern(&mut self, r#const: &core::Const) -> Pattern<()> {
+    fn check_constant_pattern(&mut self, r#const: &core::Const) -> Pattern<'arena, ()> {
         match r#const {
             core::Const::Bool(boolean) => self.check_boolean_pattern(*boolean),
             core::Const::U8(number, style) => self.check_number_pattern_styled(number, *style),

fathom/src/surface/elaboration.rs

@@ -456,8 +456,9 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
             });
         }
 
-        let filtered_fields = (fields.iter().enumerate())
-            .filter_map(move |(index, field)| (!duplicate_indices.contains(&index)).then_some(field));
+        let filtered_fields = (fields.iter().enumerate()).filter_map(move |(index, field)| {
+            (!duplicate_indices.contains(&index)).then_some(field)
+        });
 
         (labels.into(), filtered_fields)
     }
@@ -775,6 +776,8 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                     None => CheckedPattern::ReportedError(*range),
                 }
             }
+            Pattern::RecordLiteral(_, _) => todo!(),
+            Pattern::Tuple(_, _) => todo!(),
         }
     }
 
@@ -811,6 +814,8 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 let r#type = self.bool_type.clone();
                 (CheckedPattern::ConstLit(*range, r#const), r#type)
             }
+            Pattern::RecordLiteral(_, _) => todo!(),
+            Pattern::Tuple(_, _) => todo!(),
         }
     }
 
@@ -1965,7 +1970,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         &mut self,
         match_info: &MatchInfo<'arena>,
         is_reachable: bool,
-        mut equations: impl Iterator<Item = &'a (Pattern<ByteRange>, Term<'a, ByteRange>)>,
+        mut equations: impl Iterator<Item = &'a (Pattern<'a, ByteRange>, Term<'a, ByteRange>)>,
     ) -> core::Term<'arena> {
         match equations.next() {
             Some((pattern, body_expr)) => {
@@ -2042,7 +2047,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         match_info: &MatchInfo<'arena>,
         is_reachable: bool,
         (const_range, r#const, body_expr): (ByteRange, Const, core::Term<'arena>),
-        mut equations: impl Iterator<Item = &'a (Pattern<ByteRange>, Term<'a, ByteRange>)>,
+        mut equations: impl Iterator<Item = &'a (Pattern<'a, ByteRange>, Term<'a, ByteRange>)>,
     ) -> core::Term<'arena> {
         // The full range of this series of patterns
         let mut full_span = Span::merge(&const_range.into(), &body_expr.span());
@@ -2146,7 +2151,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
     fn elab_match_unreachable<'a>(
         &mut self,
         match_info: &MatchInfo<'arena>,
-        equations: impl Iterator<Item = &'a (Pattern<ByteRange>, Term<'a, ByteRange>)>,
+        equations: impl Iterator<Item = &'a (Pattern<'a, ByteRange>, Term<'a, ByteRange>)>,
     ) {
         self.elab_match(match_info, false, equations);
     }

fathom/src/surface/elaboration/order.rs

@@ -332,6 +332,8 @@ fn push_pattern(pattern: &Pattern<ByteRange>, local_names: &mut Vec<StringId>) {
         Pattern::StringLiteral(_, _) => {}
         Pattern::NumberLiteral(_, _) => {}
         Pattern::BooleanLiteral(_, _) => {}
+        Pattern::RecordLiteral(_, _) => todo!(),
+        Pattern::Tuple(_, _) => todo!(),
     }
 }
 
@@ -344,5 +346,7 @@ fn pop_pattern(pattern: &Pattern<ByteRange>, local_names: &mut Vec<StringId>) {
         Pattern::StringLiteral(_, _) => {}
         Pattern::NumberLiteral(_, _) => {}
         Pattern::BooleanLiteral(_, _) => {}
+        Pattern::RecordLiteral(_, _) => todo!(),
+        Pattern::Tuple(_, _) => todo!(),
     }
 }

fathom/src/surface/grammar.lalrpop

@@ -2,7 +2,7 @@ use scoped_arena::Scope;
 use std::cell::RefCell;
 
 use crate::source::{ByteRange, FileId, StringId, StringInterner};
-use crate::surface::{ExprField, FormatField, Item, ItemDef, Module, ParseMessage, Pattern, Term, TypeField, BinOp};
+use crate::surface::{ExprField, FormatField, Item, ItemDef, Module, ParseMessage, Pattern, PatternField, Term, TypeField, BinOp};
 use crate::surface::lexer::{Error as LexerError, Token};
 
 grammar<'arena, 'source>(
@@ -88,16 +88,18 @@ Item: Item<'arena, ByteRange> = {
     },
 };
 
-Pattern: Pattern<ByteRange> = {
+Pattern: Pattern<'arena, ByteRange> = {
     <start: @L> <name: Name> <end: @R> => Pattern::Name(ByteRange::new(file_id, start, end), name),
     <start: @L> "_" <end: @R> => Pattern::Placeholder(ByteRange::new(file_id, start, end)),
     <start: @L> <string: StringLiteral> <end: @R> => Pattern::StringLiteral(ByteRange::new(file_id, start, end), string),
     <start: @L> <number: NumberLiteral> <end: @R> => Pattern::NumberLiteral(ByteRange::new(file_id, start, end), number),
     <start: @L> "true" <end: @R> => Pattern::BooleanLiteral(ByteRange::new(file_id, start, end), true),
     <start: @L> "false" <end: @R> => Pattern::BooleanLiteral(ByteRange::new(file_id, start, end), false),
+    <start: @L> "{" <fields: Seq<PatternField,",">> "}" <end: @R> => Pattern::RecordLiteral(ByteRange::new(file_id, start, end), fields),
+    <start: @L> <patterns: Tuple<Pattern>> <end: @R> => Pattern::Tuple(ByteRange::new(file_id, start, end), patterns),
 };
 
-AnnPattern: (Pattern<ByteRange>, Option<&'arena Term<'arena, ByteRange>>) = {
+AnnPattern: (Pattern<'arena, ByteRange>, Option<&'arena Term<'arena, ByteRange>>) = {
     <pattern: Pattern> => (pattern, None),
     "(" <pattern: Pattern> ":" <type_: LetTerm> ")" => (pattern, Some(scope.to_scope(type_))),
 };
@@ -260,6 +262,10 @@ ExprField: ExprField<'arena, ByteRange> = {
     <label: RangedName> "=" <expr: Term> => ExprField { label, expr },
 };
 
+PatternField: PatternField<'arena, ByteRange> = {
+    <label: RangedName> "=" <pattern: Pattern> => PatternField { label, pattern },
+};
+
 BinExpr<Lhs, Op, Rhs>: Term<'arena, ByteRange> = {
     <start: @L> <lhs: Lhs> <op: Op> <rhs: Rhs> <end: @R> => {
         Term::BinOp(
@@ -290,8 +296,8 @@ BinOpGte: BinOp<ByteRange> = <start: @L> ">=" <end: @R> => BinOp::Gte(ByteRange:
 
 Tuple<Elem>: &'arena [Elem] = {
     "(" ")" => &[],
-    "(" <term: Term> "," ")" => scope.to_scope_from_iter([term]),
-    "(" <terms: Seq2<Term, ",">> ")" => terms,
+    "(" <term: Elem> "," ")" => scope.to_scope_from_iter([term]),
+    "(" <terms: Seq2<Elem, ",">> ")" => terms,
 };
 
 #[inline]

fathom/src/surface/pretty.rs

@@ -94,6 +94,8 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 true => self.text("true"),
                 false => self.text("false"),
             },
+            Pattern::RecordLiteral(_, _) => todo!(),
+            Pattern::Tuple(_, _) => todo!(),
         }
     }