Better context for incorrect arity message

Now it can tell the difference when a pattern has the wrong arity and
refer to it as a "pattern" instead of a "call".

compiler-core/src/error.rs

···
 use crate::strings::{to_snake_case, to_upper_camel_case};
 use crate::type_::collapse_links;
 use crate::type_::error::{
-    InvalidImportKind, MissingAnnotation, ModuleValueUsageContext, Named, UnknownField,
-    UnknownTypeHint, UnsafeRecordUpdateReason,
+    IncorrectArityContext, InvalidImportKind, MissingAnnotation, ModuleValueUsageContext, Named,
+    UnknownField, UnknownTypeHint, UnsafeRecordUpdateReason,
 };
 use crate::type_::printer::{Names, Printer};
 use crate::type_::{FieldAccessUsage, error::PatternMatchKind};
···
                 TypeError::IncorrectArity {
                     labels,
                     location,
+                    context,
                     expected,
                     given,
                 } => {
                     let text = if labels.is_empty() {
                         "".into()
                     } else {
+                        let subject = match context {
+                            IncorrectArityContext::Pattern => "pattern",
+                            IncorrectArityContext::Function => "call",
+                        };
                         let labels = labels
                             .iter()
                             .map(|p| format!("  - {p}"))
                             .sorted()
                             .join("\n");
-                        format!("This call accepts these additional labelled arguments:\n\n{labels}",)
+                        format!("This {subject} accepts these additional labelled arguments:\n\n{labels}",)
                     };
                     let expected = match expected {
                         0 => "no arguments".into(),

compiler-core/src/type_/error.rs

···
     IncorrectArity {
         location: SrcSpan,
         expected: usize,
+        context: IncorrectArityContext,
         given: usize,
         labels: Vec<EcoString>,
     },
···
     List,
     Tuple,
     Record,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IncorrectArityContext {
+    Pattern,
+    Function,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
···
         ) => Error::IncorrectArity {
             labels: vec![],
             location: call_location,
+            context: IncorrectArityContext::Function,
             expected,
             given,
         },

compiler-core/src/type_/expression.rs

···
                     .map_err(|e| convert_get_value_constructor_error(e, location, None))?
                 {
                     // The fun has a field map so labelled arguments may be present and need to be reordered.
-                    Some(field_map) => field_map.reorder(&mut args, location)?,
+                    Some(field_map) => {
+                        field_map.reorder(&mut args, location, IncorrectArityContext::Function)?
+                    }
 
                     // The fun has no field map and so we error if arguments have been labelled
                     None => assert_no_labelled_arguments(&args)?,
···
                 match field_map {
                     // The fun has a field map so labelled arguments may be
                     // present and need to be reordered.
-                    Some(field_map) => field_map.reorder(&mut args, location),
+                    Some(field_map) => {
+                        field_map.reorder(&mut args, location, IncorrectArityContext::Function)
+                    }
 
                     // The fun has no field map and so we error if arguments
                     // have been labelled.
···
                 Error::IncorrectArity {
                     expected,
                     given,
+                    context,
                     labels,
                     location,
                 } => {
···
                     self.problems.error(Error::IncorrectArity {
                         expected,
                         given,
+                        context,
                         labels,
                         location,
                     });

compiler-core/src/type_/fields.rs

···
 use super::Error;
-use crate::ast::{CallArg, SrcSpan};
+use crate::{
+    ast::{CallArg, SrcSpan},
+    type_::error::IncorrectArityContext,
+};
 use ecow::EcoString;
 use itertools::Itertools;
 use std::collections::{HashMap, HashSet};
···
     /// Reorder an argument list so that labelled fields supplied out-of-order are
     /// in the correct order.
     ///
-    pub fn reorder<A>(&self, args: &mut Vec<CallArg<A>>, location: SrcSpan) -> Result<(), Error> {
+    pub fn reorder<A>(
+        &self,
+        args: &mut Vec<CallArg<A>>,
+        location: SrcSpan,
+        context: IncorrectArityContext,
+    ) -> Result<(), Error> {
         let mut labelled_arguments_given = false;
         let mut seen_labels = HashSet::new();
         let mut unknown_labels = Vec::new();
···
             return Err(Error::IncorrectArity {
                 labels: self.incorrect_arity_labels(args),
                 location,
+                context,
                 expected: self.arity as usize,
                 given: args.len(),
             });

compiler-core/src/type_/pattern.rs

···
                         self.error(Error::IncorrectArity {
                             labels: vec![],
                             location,
+                            context: IncorrectArityContext::Pattern,
                             expected: type_elements.len(),
                             given: elements.len(),
                         });
···
                             }
                         }
 
-                        if let Err(error) = field_map.reorder(&mut pattern_args, location) {
+                        if let Err(error) = field_map.reorder(
+                            &mut pattern_args,
+                            location,
+                            IncorrectArityContext::Pattern,
+                        ) {
                             {
                                 self.problems.error(error);
                                 self.error_encountered = true;
···
                             self.error(Error::IncorrectArity {
                                 labels: vec![],
                                 location,
+                                context: IncorrectArityContext::Pattern,
                                 expected: args.len(),
                                 given: pattern_args.len(),
                             });
···
                             self.error(Error::IncorrectArity {
                                 labels: vec![],
                                 location,
+                                context: IncorrectArityContext::Pattern,
                                 expected: 0,
                                 given: pattern_args.len(),
                             });

compiler-core/src/type_/tests.rs

···
                 fields: self.fields,
             };
             let location = SrcSpan { start: 0, end: 0 };
-            assert_eq!(self.expected_result, fm.reorder(&mut args, location));
+            assert_eq!(
+                self.expected_result,
+                fm.reorder(&mut args, location, IncorrectArityContext::Function)
+            );
             assert_eq!(self.expected_args, args);
         }
     }