Update to rustfmt 1.6.0-nightly (839e9a6 2023-07-02)

Summary:
Update to rustfmt 1.6.0-nightly (839e9a6 2023-07-02)

The big ticket item here is that let-else is now supported! In fact, the
suppport just landed two days ago (see [rust-lang/rustfmt#4914])

The unfortunate thing here though is that rustfmt is not statically
linked anymore (see discussion in [rust-lang/rust#107297]). So we need
all of librustc_driver and libstd - which makes our use case pretty big
(~4-5MB to 50MB-100MB). We should explore building from source and
statically linking, or using rustfmt from the toolchain. Both things
that I don't want to deal with right now.

[rust-lang/rustfmt#4914]: rust-lang/rustfmt#4914
[rust-lang/rust#107297]: rust-lang/rust#107297

Note to future updaters: To find out more-or-less what libs you need,
you can use `objdump -p bin/rustfmt | grep NEEDED` on Linux for ELF
bins, and `otool -L bin/rustfmt` on macOS for Mach-O bins. No idea what
you do for Windows.

Ran `tools/arcanist/lint/codemods/rustfmt-fbsource` to format the repo.

Reviewed By: shayne-fletcher

Differential Revision: D47203254

fbshipit-source-id: 6ffd3ce66c7f2b006d09505b93fed515ebc76902

Author: zertosh

starlark/src/eval/compiler/types.rs

@@ -73,10 +73,14 @@ impl<'v> Compiler<'v, '_, '_> {
         let Some(type_value) = expr.payload else {
             // This is unreachable. But unfortunately we do not return error here.
             // Still make an error in panic to produce nice panic message.
-            panic!("{:?}", EvalException::new(
-                TypesError::TypePayloadNotSet.into(),
-                expr.span,
-                &self.codemap));
+            panic!(
+                "{:?}",
+                EvalException::new(
+                    TypesError::TypePayloadNotSet.into(),
+                    expr.span,
+                    &self.codemap
+                )
+            );
         };
         if type_value.type_is_wildcard() {
             return None;

starlark/src/values/types/int_or_big.rs

@@ -362,7 +362,7 @@ impl<'v> StarlarkIntRef<'v> {
                 Ok(StarlarkInt::Small(InlineInt::MINUS_ONE))
             } else {
                 Ok(StarlarkInt::Small(InlineInt::ZERO))
-            }
+            };
         };
 
         match self {

starlark/src/values/types/string/interpolation.rs

@@ -152,7 +152,9 @@ impl<'a> Iterator for PercentFormatParser<'a> {
                         _ => {
                             // Note we need to find the second character, not the second byte.
                             let Some(c) = rem.chars().nth(1) else {
-                                return Some(Err(StringInterpolationError::ExpectingFormatCharacter.into()));
+                                return Some(Err(
+                                    StringInterpolationError::ExpectingFormatCharacter.into(),
+                                ));
                             };
                             return Some(Err(
                                 StringInterpolationError::UnsupportedFormatCharacter(c).into(),

starlark_derive/src/starlark_value.rs

@@ -89,16 +89,10 @@ fn is_impl_starlark_value(
 ) -> syn::Result<ImplStarlarkValue> {
     let err = "expected `impl StarlarkValue for ...`";
     let Some((_, path, _)) = &input.trait_ else {
-        return Err(syn::Error::new_spanned(
-            input,
-            err,
-        ));
+        return Err(syn::Error::new_spanned(input, err));
     };
     let Some(last) = path.segments.last() else {
-        return Err(syn::Error::new_spanned(
-            path,
-            err,
-        ));
+        return Err(syn::Error::new_spanned(path, err));
     };
     if last.ident != "StarlarkValue" {
         return Err(syn::Error::new_spanned(&last.ident, err));