Pretty print record and tuple patterns

Author: Kmeakin

fathom/src/surface/pretty.rs

@@ -94,8 +94,20 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 true => self.text("true"),
                 false => self.text("false"),
             },
-            Pattern::RecordLiteral(_, _) => todo!(),
-            Pattern::Tuple(_, _) => todo!(),
+            Pattern::RecordLiteral(_, pattern_fields) => {
+                self.pretty_record(pattern_fields, |field| {
+                    self.concat([
+                        self.string_id(field.label.1),
+                        self.space(),
+                        self.text("="),
+                        self.space(),
+                        self.pattern(&field.pattern),
+                    ])
+                })
+            }
+            Pattern::Tuple(_, patterns) => {
+                self.pretty_tuple(patterns, |pattern| self.pattern(pattern))
+            }
         }
     }
 
@@ -262,49 +274,25 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                     ),
                 ]),
             ),
-            Term::RecordType(_, type_fields) => self.sequence(
-                true,
-                self.text("{"),
-                type_fields.iter().map(|field| {
-                    self.concat([
-                        self.string_id(field.label.1),
-                        self.space(),
-                        self.text(":"),
-                        self.space(),
-                        self.term_prec(Prec::Top, &field.type_),
-                    ])
-                }),
-                self.text(","),
-                self.text("}"),
-            ),
-            Term::RecordLiteral(_, expr_fields) => self.sequence(
-                true,
-                self.text("{"),
-                expr_fields.iter().map(|field| {
-                    self.concat([
-                        self.string_id(field.label.1),
-                        self.space(),
-                        self.text("="),
-                        self.space(),
-                        self.term_prec(Prec::Top, &field.expr),
-                    ])
-                }),
-                self.text(","),
-                self.text("}"),
-            ),
-            Term::Tuple(_, terms) if terms.len() == 1 => self.concat([
-                self.text("("),
-                self.term(&terms[0]),
-                self.text(","),
-                self.text(")"),
-            ]),
-            Term::Tuple(_, terms) => self.sequence(
-                false,
-                self.text("("),
-                terms.iter().map(|term| self.term(term)),
-                self.text(","),
-                self.text(")"),
-            ),
+            Term::RecordType(_, type_fields) => self.pretty_record(type_fields, |field| {
+                self.concat([
+                    self.string_id(field.label.1),
+                    self.space(),
+                    self.text(":"),
+                    self.space(),
+                    self.term_prec(Prec::Top, &field.type_),
+                ])
+            }),
+            Term::RecordLiteral(_, expr_fields) => self.pretty_record(expr_fields, |field| {
+                self.concat([
+                    self.string_id(field.label.1),
+                    self.space(),
+                    self.text("="),
+                    self.space(),
+                    self.term_prec(Prec::Top, &field.expr),
+                ])
+            }),
+            Term::Tuple(_, terms) => self.pretty_tuple(terms, |term| self.term(term)),
             Term::Proj(_, head_expr, labels) => self.concat([
                 self.term_prec(Prec::Atomic, head_expr),
                 self.concat(
@@ -583,6 +571,45 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         self.paren(prec > Prec::Let, DocBuilder::flat_alt(multi, single))
             .group()
     }
+
+    fn pretty_tuple<T>(
+        &'arena self,
+        terms: &[T],
+        pretty: impl Fn(&T) -> DocBuilder<'arena, Self>,
+    ) -> DocBuilder<'arena, Self> {
+        if terms.len() == 1 {
+            self.concat([
+                self.text("("),
+                pretty(&terms[0]),
+                self.text(","),
+                self.text(")"),
+            ])
+        } else {
+            #[allow(clippy::redundant_closure)]
+            self.sequence(
+                false,
+                self.text("("),
+                terms.iter().map(|term| pretty(term)),
+                self.text(","),
+                self.text(")"),
+            )
+        }
+    }
+
+    fn pretty_record<T>(
+        &'arena self,
+        fields: &[T],
+        pretty: impl Fn(&T) -> DocBuilder<'arena, Self>,
+    ) -> DocBuilder<'arena, Self> {
+        #[allow(clippy::redundant_closure)]
+        self.sequence(
+            true,
+            self.text("{"),
+            fields.iter().map(|field| pretty(field)),
+            self.text(","),
+            self.text("}"),
+        )
+    }
 }
 
 macro_rules! borrowed_text {