Move tuple/record handling into separate functions

Author: Kmeakin

fathom/src/surface/elaboration.rs

@@ -1046,19 +1046,12 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 let (synth_term, synth_type) = self.synth_and_insert_implicit_apps(surface_term);
                 self.coerce(surface_range, synth_term, &synth_type, &expected_type)
             }
-            (Term::RecordLiteral(_, expr_fields), Value::RecordType(labels, types)) => {
+            (Term::RecordLiteral(range, expr_fields), Value::RecordType(labels, types)) => {
                 // TODO: improve handling of duplicate labels
-                if expr_fields.len() != labels.len()
-                    || Iterator::zip(expr_fields.iter(), labels.iter())
-                        .any(|(expr_field, type_label)| expr_field.label.1 != *type_label)
+                if self
+                    .check_record_fields(*range, expr_fields, |field| field.label, labels)
+                    .is_err()
                 {
-                    self.push_message(Message::MismatchedFieldLabels {
-                        range: file_range,
-                        expr_labels: (expr_fields.iter())
-                            .map(|ExprField { label, .. }| (self.file_range(label.0), label.1))
-                            .collect(),
-                        type_labels: labels.to_vec(),
-                    });
                     return core::Term::Prim(file_range.into(), Prim::ReportedError);
                 }
 
@@ -1121,33 +1114,11 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                     core::Term::FormatRecord(file_range.into(), labels, formats)
                 })
             }
-            (Term::Tuple(_, elem_exprs), Value::RecordType(labels, types)) => {
-                if elem_exprs.len() != labels.len() {
-                    let mut expr_labels = Vec::with_capacity(elem_exprs.len());
-                    let mut elem_exprs = elem_exprs.iter().enumerate().peekable();
-                    let mut label_iter = labels.iter();
-
-                    // use the label names from the expected type
-                    while let Some(((_, elem_expr), label)) =
-                        Option::zip(elem_exprs.peek(), label_iter.next())
-                    {
-                        expr_labels.push((self.file_range(elem_expr.range()), *label));
-                        elem_exprs.next();
-                    }
-
-                    // use numeric labels for excess elems
-                    for (index, elem_expr) in elem_exprs {
-                        expr_labels.push((
-                            self.file_range(elem_expr.range()),
-                            self.interner.borrow_mut().get_tuple_label(index),
-                        ));
-                    }
-
-                    self.push_message(Message::MismatchedFieldLabels {
-                        range: file_range,
-                        expr_labels,
-                        type_labels: labels.to_vec(),
-                    });
+            (Term::Tuple(range, elem_exprs), Value::RecordType(labels, types)) => {
+                if self
+                    .check_tuple_fields(*range, elem_exprs, |term| term.range(), labels)
+                    .is_err()
+                {
                     return core::Term::Prim(file_range.into(), Prim::ReportedError);
                 }
 
@@ -2218,6 +2189,76 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         (labels, formats.into())
     }
 
+    fn check_tuple_fields<F>(
+        &mut self,
+        range: ByteRange,
+        fields: &[F],
+        get_range: fn(&F) -> ByteRange,
+        expected_labels: &[StringId],
+    ) -> Result<(), ()> {
+        if fields.len() == expected_labels.len() {
+            return Ok(());
+        }
+
+        let mut found_labels = Vec::with_capacity(fields.len());
+        let mut fields_iter = fields.iter().enumerate().peekable();
+        let mut expected_labels_iter = expected_labels.iter();
+
+        // use the label names from the expected labels
+        while let Some(((_, field), label)) =
+            Option::zip(fields_iter.peek(), expected_labels_iter.next())
+        {
+            found_labels.push((self.file_range(get_range(field)), *label));
+            fields_iter.next();
+        }
+
+        // use numeric labels for excess fields
+        for (index, field) in fields_iter {
+            found_labels.push((
+                self.file_range(get_range(field)),
+                self.interner.borrow_mut().get_tuple_label(index),
+            ));
+        }
+
+        self.push_message(Message::MismatchedFieldLabels {
+            range: self.file_range(range),
+            found_labels,
+            expected_labels: expected_labels.to_vec(),
+        });
+        Err(())
+    }
+
+    fn check_record_fields<F>(
+        &mut self,
+        range: ByteRange,
+        fields: &[F],
+        get_label: impl Fn(&F) -> (ByteRange, StringId),
+        labels: &'arena [StringId],
+    ) -> Result<(), ()> {
+        if fields.len() == labels.len()
+            && fields
+                .iter()
+                .zip(labels.iter())
+                .all(|(field, type_label)| get_label(field).1 == *type_label)
+        {
+            return Ok(());
+        }
+
+        // TODO: improve handling of duplicate labels
+        self.push_message(Message::MismatchedFieldLabels {
+            range: self.file_range(range),
+            found_labels: fields
+                .iter()
+                .map(|field| {
+                    let (range, label) = get_label(field);
+                    (self.file_range(range), label)
+                })
+                .collect(),
+            expected_labels: labels.to_vec(),
+        });
+        Err(())
+    }
+
     /// Elaborate a match expression in checking mode
     fn check_match(
         &mut self,

fathom/src/surface/elaboration/reporting.rs

@@ -52,8 +52,8 @@ pub enum Message {
     },
     MismatchedFieldLabels {
         range: FileRange,
-        expr_labels: Vec<(FileRange, StringId)>,
-        type_labels: Vec<StringId>,
+        found_labels: Vec<(FileRange, StringId)>,
+        expected_labels: Vec<StringId>,
         // TODO: add expected type
         // expected_type: Doc<_>,
     },
@@ -243,17 +243,17 @@ impl Message {
             }
             Message::MismatchedFieldLabels {
                 range,
-                expr_labels,
-                type_labels,
+                found_labels,
+                expected_labels,
             } => {
                 let interner = interner.borrow();
-                let mut diagnostic_labels = Vec::with_capacity(expr_labels.len());
+                let mut diagnostic_labels = Vec::with_capacity(found_labels.len());
                 {
-                    let mut type_labels = type_labels.iter().peekable();
+                    let mut expected_labels = expected_labels.iter().peekable();
 
-                    'expr_labels: for (range, expr_label) in expr_labels.iter() {
+                    'expr_labels: for (range, expr_label) in found_labels.iter() {
                         'type_labels: loop {
-                            match type_labels.next() {
+                            match expected_labels.next() {
                                 None => {
                                     let expr_label = interner.resolve(*expr_label).unwrap();
                                     diagnostic_labels.push(
@@ -279,10 +279,10 @@ impl Message {
                         }
                     }
 
-                    if type_labels.peek().is_some() {
+                    if expected_labels.peek().is_some() {
                         diagnostic_labels.push(primary_label(range).with_message(format!(
                             "missing fields {}",
-                            type_labels
+                            expected_labels
                                 .map(|label| interner.resolve(*label).unwrap())
                                 .format_with(", ", |label, f| f(&format_args!("`{label}`"))),
                         )));
@@ -292,10 +292,10 @@ impl Message {
                     }
                 }
 
-                let found_labels = (expr_labels.iter())
+                let found_labels = (found_labels.iter())
                     .map(|(_, label)| interner.resolve(*label).unwrap())
                     .format_with(", ", |label, f| f(&format_args!("`{label}`")));
-                let expected_labels = (type_labels.iter())
+                let expected_labels = (expected_labels.iter())
                     .map(|label| interner.resolve(*label).unwrap())
                     .format_with(", ", |label, f| f(&format_args!("`{label}`")));