Rollup merge of #152293 - ia0:try_blocks_heterogeneous, r=ytmimi

Format heterogeneous try blocks

The tracking issue for `try_blocks_heterogeneous` is rust-lang/rust#149488.

This follows the formatting of homogeneous try blocks (feature `try_blocks`) by considering `try bikeshed <type>` to be the equivalent of `try` (in particular a single "token").

An alternative would be to permit breaking between `bikeshed` and `<type>`, but given that those 2 elements are an explicitly temporary part of the syntax, it doesn't seem worth it. There also doesn't seem to be any existing precedent breaking between a keyword and a type. It also doesn't seem to be useful in practice, given that the type itself doesn't break (which is how it works for the return type of closures) and has more chances to dominate the length in case a break is necessary.

Happy to adapt anything in case this formatting is not optimal.

The test is also copied from homogeneous try blocks with 2 additional test cases to demonstrate the behavior with long types.

See [#t-lang > try blocks @ 💬](https://rust-lang.zulipchat.com/#narrow/channel/213817-t-lang/topic/try.20blocks/near/572387493) for context.

Author: JonathanBrouwer

src/expr.rs

@@ -385,8 +385,33 @@ pub(crate) fn format_expr(
                 ))
             }
         }
-        // FIXME: heterogeneous try blocks, which include a type so are harder to format
-        ast::ExprKind::TryBlock(_, Some(_)) => Err(RewriteError::Unknown),
+        ast::ExprKind::TryBlock(ref block, Some(ref ty)) => {
+            let keyword = "try bikeshed ";
+            // 2 = " {".len()
+            let ty_shape = shape
+                .shrink_left(keyword.len())
+                .and_then(|shape| shape.sub_width(2))
+                .max_width_error(shape.width, expr.span)?;
+            let ty_str = ty.rewrite_result(context, ty_shape)?;
+            let prefix = format!("{keyword}{ty_str} ");
+            if let rw @ Ok(_) =
+                rewrite_single_line_block(context, &prefix, block, Some(&expr.attrs), None, shape)
+            {
+                rw
+            } else {
+                let budget = shape.width.saturating_sub(prefix.len());
+                Ok(format!(
+                    "{prefix}{}",
+                    rewrite_block(
+                        block,
+                        Some(&expr.attrs),
+                        None,
+                        context,
+                        Shape::legacy(budget, shape.indent)
+                    )?
+                ))
+            }
+        }
         ast::ExprKind::Gen(capture_by, ref block, ref kind, _) => {
             let mover = if matches!(capture_by, ast::CaptureBy::Value { .. }) {
                 "move "

tests/source/try_block.rs

@@ -1,4 +1,5 @@
 // rustfmt-edition: 2018
+#![feature(try_blocks)]
 
 fn main() -> Result<(), !> {
     let _x: Option<_> = try {

tests/source/try_blocks_heterogeneous.rs

@@ -0,0 +1,39 @@
+// rustfmt-edition: 2018
+#![feature(try_blocks_heterogeneous)]
+
+fn main() -> Result<(), !> {
+    let _x = try bikeshed Option<_> {
+        4
+    };
+
+    try bikeshed Result<_, _> {}
+}
+
+fn baz() -> Option<i32> {
+    if (1 == 1) {
+        return try bikeshed Option<i32> {
+            5
+        };
+    }
+
+    // test
+    let x = try bikeshed Option<()> {
+        // try blocks are great
+    };
+
+    let y = try bikeshed Option<i32> {
+        6
+    }; // comment
+
+    let x = try /* Invisible comment */ bikeshed Option<()> {};
+    let x = try bikeshed /* Invisible comment */ Option<()> {};
+    let x = try bikeshed Option<()> /* Invisible comment */ {};
+
+    let x = try bikeshed Option<i32> { baz()?; baz()?; baz()?; 7 };
+
+    let x = try bikeshed Foo<Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar> { 1 + 1 + 1 };
+
+    let x = try bikeshed Foo<Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar> {};
+
+    return None;
+}

tests/target/try_block.rs

@@ -1,4 +1,5 @@
 // rustfmt-edition: 2018
+#![feature(try_blocks)]
 
 fn main() -> Result<(), !> {
     let _x: Option<_> = try { 4 };

tests/target/try_blocks_heterogeneous.rs

@@ -0,0 +1,41 @@
+// rustfmt-edition: 2018
+#![feature(try_blocks_heterogeneous)]
+
+fn main() -> Result<(), !> {
+    let _x = try bikeshed Option<_> { 4 };
+
+    try bikeshed Result<_, _> {}
+}
+
+fn baz() -> Option<i32> {
+    if (1 == 1) {
+        return try bikeshed Option<i32> { 5 };
+    }
+
+    // test
+    let x = try bikeshed Option<()> {
+        // try blocks are great
+    };
+
+    let y = try bikeshed Option<i32> { 6 }; // comment
+
+    let x = try /* Invisible comment */ bikeshed Option<()> {};
+    let x = try bikeshed /* Invisible comment */ Option<()> {};
+    let x = try bikeshed Option<()> /* Invisible comment */ {};
+
+    let x = try bikeshed Option<i32> {
+        baz()?;
+        baz()?;
+        baz()?;
+        7
+    };
+
+    let x = try bikeshed Foo<Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar> {
+        1 + 1 + 1
+    };
+
+    let x =
+        try bikeshed Foo<Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar, Bar> {};
+
+    return None;
+}