Fix rustfmt formatting after merge

Author: Keviniscool-boy

pyrefly/lib/alt/callable.rs

@@ -947,15 +947,16 @@ fn guarded_param_subject(
     argmap: &ArgMap,
     keywords: &[CallKeyword],
 ) -> Option<GuardSubject> {
-    let designated = params
-        .items()
-        .get(usize::from(has_self_arg))
-        .and_then(|param| match param {
-            Param::Pos(name, _, _) | Param::PosOnly(Some(name), _, _) => Some(name),
-            // Positional-only parameters without a name can't be looked up, and a
-            // `TypeGuard`/`TypeIs` designation never lands on other parameter kinds.
-            _ => None,
-        })?;
+    let designated =
+        params
+            .items()
+            .get(usize::from(has_self_arg))
+            .and_then(|param| match param {
+                Param::Pos(name, _, _) | Param::PosOnly(Some(name), _, _) => Some(name),
+                // Positional-only parameters without a name can't be looked up, and a
+                // `TypeGuard`/`TypeIs` designation never lands on other parameter kinds.
+                _ => None,
+            })?;
     let (argument, _) = argmap
         .arg_to_param
         .iter()
@@ -2699,8 +2700,7 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                     context,
                     &call_context,
                 );
-                let guard_subject =
-                    guarded_param_subject(&params, has_self_arg, &argmap, keywords);
+                let guard_subject = guarded_param_subject(&params, has_self_arg, &argmap, keywords);
                 (argmap, guard_subject)
             }
             Params::Ellipsis | Params::Materialization => {

pyrefly/lib/alt/narrow.rs

@@ -729,12 +729,7 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
     /// the callee's `TypeGuard`/`TypeIs` result. The call is resolved with the ordinary
     /// call machinery (argument matching included, errors swallowed), and the guarded
     /// argument comes from the same resolution as the result.
-    fn keyword_is_guard_subject(
-        &self,
-        func_ty: &Type,
-        call: &NarrowingCall,
-        kws: &[Name],
-    ) -> bool {
+    fn keyword_is_guard_subject(&self, func_ty: &Type, call: &NarrowingCall, kws: &[Name]) -> bool {
         let CallTargetLookup::Ok(call_target) = self.as_call_target(func_ty.clone()) else {
             return false;
         };

pyrefly/lib/alt/overload.rs

@@ -1196,25 +1196,32 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
 
         let arg_errors = self.error_collector();
         let call_errors = self.error_collector();
-        let (res, specialization_errors, return_type_errors, argmap, defaults_used, table, guard_subject) =
-            self.callable_infer(
-                callable.1.signature.clone(),
-                Some(&metadata.kind),
-                tparams,
-                self_obj.cloned(),
-                args,
-                keywords,
-                arguments_range,
-                &arg_errors,
-                &call_errors,
-                // We intentionally drop the context here, as arg errors don't need it,
-                // and if there are any call errors, we'll log a "No matching overloads"
-                // error with the necessary context.
-                None,
-                hint,
-                contextually_opaque_defaults,
-                overload_ctor_targs.as_mut(),
-            );
+        let (
+            res,
+            specialization_errors,
+            return_type_errors,
+            argmap,
+            defaults_used,
+            table,
+            guard_subject,
+        ) = self.callable_infer(
+            callable.1.signature.clone(),
+            Some(&metadata.kind),
+            tparams,
+            self_obj.cloned(),
+            args,
+            keywords,
+            arguments_range,
+            &arg_errors,
+            &call_errors,
+            // We intentionally drop the context here, as arg errors don't need it,
+            // and if there are any call errors, we'll log a "No matching overloads"
+            // error with the necessary context.
+            None,
+            hint,
+            contextually_opaque_defaults,
+            overload_ctor_targs.as_mut(),
+        );
         CalledOverload {
             func: callable,
             res,

pyrefly/lib/binding/narrow.rs

@@ -987,10 +987,8 @@ impl NarrowOps {
             match self.0.entry(name) {
                 Entry::Occupied(mut entry) => {
                     let (op, _) = entry.get_mut();
-                    if let NarrowOp::Atomic(
-                        existing_prop,
-                        AtomicNarrowOp::Call(existing_call, kws),
-                    ) = op
+                    if let NarrowOp::Atomic(existing_prop, AtomicNarrowOp::Call(existing_call, kws)) =
+                        op
                         && Arc::ptr_eq(existing_call, call)
                         && Self::same_facet_subject(existing_prop.as_ref(), prop.as_ref())
                     {