style: rustfmt

Signed-off-by: Andrey <andrekabatareika@gmail.com>

Author: ankddev

compiler-core/src/error.rs

@@ -10,7 +10,8 @@ use crate::strings::{to_snake_case, to_upper_camel_case};
 use crate::type_::collapse_links;
 use crate::type_::error::{
     IncorrectArityContext, InvalidImportKind, MissingAnnotation, ModuleValueUsageContext, Named,
-    RecordField, UnexpectedLabelledArgKind, UnknownField, UnknownTypeHint, UnsafeRecordUpdateReason,
+    RecordField, UnexpectedLabelledArgKind, UnknownField, UnknownTypeHint,
+    UnsafeRecordUpdateReason,
 };
 use crate::type_::printer::{Names, Printer};
 use crate::type_::{FieldAccessUsage, error::PatternMatchKind};
@@ -1769,10 +1770,16 @@ constructor accepts."
                         }
                     }
 
-                    TypeError::UnexpectedLabelledArg { location, label, kind } => {
+                    TypeError::UnexpectedLabelledArg {
+                        location,
+                        label,
+                        kind,
+                    } => {
                         let kind = match kind {
                             UnexpectedLabelledArgKind::FunctionParameter => "function",
-                            UnexpectedLabelledArgKind::RecordConstructorArgument => "record constructor",
+                            UnexpectedLabelledArgKind::RecordConstructorArgument => {
+                                "record constructor"
+                            }
                         };
                         let text = format!(
                             "This argument has been given a label but the {kind} does

compiler-core/src/type_.rs

@@ -1524,7 +1524,10 @@ impl ValueConstructor {
 
 pub type TypedCallArg = CallArg<TypedExpr>;
 
-fn assert_no_labelled_arguments<A>(arguments: &[CallArg<A>], kind: UnexpectedLabelledArgKind) -> Result<(), Error> {
+fn assert_no_labelled_arguments<A>(
+    arguments: &[CallArg<A>],
+    kind: UnexpectedLabelledArgKind,
+) -> Result<(), Error> {
     for argument in arguments {
         if let Some(label) = &argument.label {
             return Err(Error::UnexpectedLabelledArg {

compiler-core/src/type_/expression.rs

@@ -4144,8 +4144,16 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     }
                     // The fun or constructor has no field map and so we error
                     // if arguments have been labelled.
-                    Ok(None) if fun.is_record_constructor_function() => assert_no_labelled_arguments(&arguments, UnexpectedLabelledArgKind::RecordConstructorArgument),
-                    Ok(None) => assert_no_labelled_arguments(&arguments, UnexpectedLabelledArgKind::FunctionParameter),
+                    Ok(None) if fun.is_record_constructor_function() => {
+                        assert_no_labelled_arguments(
+                            &arguments,
+                            UnexpectedLabelledArgKind::RecordConstructorArgument,
+                        )
+                    }
+                    Ok(None) => assert_no_labelled_arguments(
+                        &arguments,
+                        UnexpectedLabelledArgKind::FunctionParameter,
+                    ),
                 };
 
                 // If there's an error reordering the fields, or there's labelled
@@ -4542,8 +4550,14 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     // known to be a valid function we can make sure that there's
                     // no labelled arguments if it doesn't actually have a field map.
                     None if fun.is_invalid() => Ok(()),
-                    None if fun.is_record_constructor_function() => assert_no_labelled_arguments(&arguments, UnexpectedLabelledArgKind::RecordConstructorArgument),
-                    None => assert_no_labelled_arguments(&arguments, UnexpectedLabelledArgKind::FunctionParameter),
+                    None if fun.is_record_constructor_function() => assert_no_labelled_arguments(
+                        &arguments,
+                        UnexpectedLabelledArgKind::RecordConstructorArgument,
+                    ),
+                    None => assert_no_labelled_arguments(
+                        &arguments,
+                        UnexpectedLabelledArgKind::FunctionParameter,
+                    ),
                 }
             });
 

compiler-core/src/type_/pattern.rs

@@ -1101,7 +1101,10 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                     None => {
                         // The fun or constructor has no field map and so we
                         // error if arguments have been labelled
-                        match assert_no_labelled_arguments(&pattern_arguments, UnexpectedLabelledArgKind::RecordConstructorArgument) {
+                        match assert_no_labelled_arguments(
+                            &pattern_arguments,
+                            UnexpectedLabelledArgKind::RecordConstructorArgument,
+                        ) {
                             Ok(()) => {}
                             Err(error) => {
                                 self.problems.error(error);