From 025c0706e49a3158c07d68dbdaac2a39d42c5a5a Mon Sep 17 00:00:00 2001 From: AsthaMishra Date: Wed, 2 Sep 2026 23:18:20 +0000 Subject: [PATCH 1/3] reserved width for unsafe in match arm pattern --- src/matches.rs | 6 ++++++ tests/source/issue_6848.rs | 20 ++++++++++++++++++++ tests/target/issue_6848.rs | 19 +++++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 tests/source/issue_6848.rs create mode 100644 tests/target/issue_6848.rs diff --git a/src/matches.rs b/src/matches.rs index 4e82df98de4..8d3859a456a 100644 --- a/src/matches.rs +++ b/src/matches.rs @@ -286,6 +286,12 @@ fn rewrite_match_arm( .sub_width(7 + label_len, arm.span)? .offset_left(pipe_offset, arm.span)? } + ast::ExprKind::Block(block, None) if is_unsafe_block(block) => { + // 12 = ` => unsafe {` + shape + .sub_width(12, arm.span)? + .offset_left(pipe_offset, arm.span)? + } _ => { // 5 = ` => {` shape diff --git a/tests/source/issue_6848.rs b/tests/source/issue_6848.rs new file mode 100644 index 00000000000..08fe9f47e7f --- /dev/null +++ b/tests/source/issue_6848.rs @@ -0,0 +1,20 @@ +// rustfmt-max_width: 80 + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { + } + _ => {} + } +} + +fn main() {} \ No newline at end of file diff --git a/tests/target/issue_6848.rs b/tests/target/issue_6848.rs new file mode 100644 index 00000000000..c44ef5f2e75 --- /dev/null +++ b/tests/target/issue_6848.rs @@ -0,0 +1,19 @@ +// rustfmt-max_width: 80 + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe {}, + _ => {} + } +} + +fn main() {} From af652e0c90e4ec5034f40b9f383066c757b13ae3 Mon Sep 17 00:00:00 2001 From: AsthaMishra Date: Thu, 3 Sep 2026 21:36:06 +0000 Subject: [PATCH 2/3] test case added for other blocks and style edition gate added, test files also updated for same --- src/matches.rs | 5 +- tests/source/issue_6848.rs | 20 ------ tests/source/issue_6848_style_edition_2024.rs | 63 +++++++++++++++++++ tests/source/issue_6848_style_edition_2027.rs | 63 +++++++++++++++++++ tests/target/issue_6848.rs | 19 ------ tests/target/issue_6848_style_edition_2024.rs | 52 +++++++++++++++ tests/target/issue_6848_style_edition_2027.rs | 54 ++++++++++++++++ 7 files changed, 236 insertions(+), 40 deletions(-) delete mode 100644 tests/source/issue_6848.rs create mode 100644 tests/source/issue_6848_style_edition_2024.rs create mode 100644 tests/source/issue_6848_style_edition_2027.rs delete mode 100644 tests/target/issue_6848.rs create mode 100644 tests/target/issue_6848_style_edition_2024.rs create mode 100644 tests/target/issue_6848_style_edition_2027.rs diff --git a/src/matches.rs b/src/matches.rs index 8d3859a456a..8a689d0beae 100644 --- a/src/matches.rs +++ b/src/matches.rs @@ -286,7 +286,10 @@ fn rewrite_match_arm( .sub_width(7 + label_len, arm.span)? .offset_left(pipe_offset, arm.span)? } - ast::ExprKind::Block(block, None) if is_unsafe_block(block) => { + ast::ExprKind::Block(block, None) + if is_unsafe_block(block) + && context.config.style_edition() >= StyleEdition::Edition2027 => + { // 12 = ` => unsafe {` shape .sub_width(12, arm.span)? diff --git a/tests/source/issue_6848.rs b/tests/source/issue_6848.rs deleted file mode 100644 index 08fe9f47e7f..00000000000 --- a/tests/source/issue_6848.rs +++ /dev/null @@ -1,20 +0,0 @@ -// rustfmt-max_width: 80 - -#[derive(Clone, Copy)] -enum ExampleTypeX { - VariantAlphaSampleXYZ, - VariantBetaXYZ, -} - -fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { - match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => unsafe { - } - _ => {} - } -} - -fn main() {} \ No newline at end of file diff --git a/tests/source/issue_6848_style_edition_2024.rs b/tests/source/issue_6848_style_edition_2024.rs new file mode 100644 index 00000000000..3ce14d8ec59 --- /dev/null +++ b/tests/source/issue_6848_style_edition_2024.rs @@ -0,0 +1,63 @@ +// rustfmt-style_edition: 2024 +// rustfmt-max_width: 80 + +#![feature(gen_blocks, try_blocks)] + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { + } + _ => {} + } + + // const block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => const { + } + _ => {} + } + + // async block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => async { + }, + _ => {} + } + + // gen block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => gen { + }, + _ => {} + } + + // try block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => try { + }, + _ => {} + } +} + +fn main() {} \ No newline at end of file diff --git a/tests/source/issue_6848_style_edition_2027.rs b/tests/source/issue_6848_style_edition_2027.rs new file mode 100644 index 00000000000..8cfcfd5efe1 --- /dev/null +++ b/tests/source/issue_6848_style_edition_2027.rs @@ -0,0 +1,63 @@ +// rustfmt-style_edition: 2027 +// rustfmt-max_width: 80 + +#![feature(gen_blocks, try_blocks)] + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { + } + _ => {} + } + + // const block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => const { + } + _ => {} + } + + // async block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => async { + }, + _ => {} + } + + // gen block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => gen { + }, + _ => {} + } + + // try block + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => try { + }, + _ => {} + } +} + +fn main() {} \ No newline at end of file diff --git a/tests/target/issue_6848.rs b/tests/target/issue_6848.rs deleted file mode 100644 index c44ef5f2e75..00000000000 --- a/tests/target/issue_6848.rs +++ /dev/null @@ -1,19 +0,0 @@ -// rustfmt-max_width: 80 - -#[derive(Clone, Copy)] -enum ExampleTypeX { - VariantAlphaSampleXYZ, - VariantBetaXYZ, -} - -fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { - match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => unsafe {}, - _ => {} - } -} - -fn main() {} diff --git a/tests/target/issue_6848_style_edition_2024.rs b/tests/target/issue_6848_style_edition_2024.rs new file mode 100644 index 00000000000..5d0231dde9a --- /dev/null +++ b/tests/target/issue_6848_style_edition_2024.rs @@ -0,0 +1,52 @@ +// rustfmt-style_edition: 2024 +// rustfmt-max_width: 80 + +#![feature(gen_blocks, try_blocks)] + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => unsafe { + }, + _ => {} + } + + // const block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + const {} + } + _ => {} + } + + // async block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + async {} + } + _ => {} + } + + // gen block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + gen {} + } + _ => {} + } + + // try block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + try {} + } + _ => {} + } +} + +fn main() {} diff --git a/tests/target/issue_6848_style_edition_2027.rs b/tests/target/issue_6848_style_edition_2027.rs new file mode 100644 index 00000000000..c5cb718a972 --- /dev/null +++ b/tests/target/issue_6848_style_edition_2027.rs @@ -0,0 +1,54 @@ +// rustfmt-style_edition: 2027 +// rustfmt-max_width: 80 + +#![feature(gen_blocks, try_blocks)] + +#[derive(Clone, Copy)] +enum ExampleTypeX { + VariantAlphaSampleXYZ, + VariantBetaXYZ, +} + +fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + match (lhs, rhs) { + ( + ExampleTypeX::VariantAlphaSampleXYZ, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe {}, + _ => {} + } + + // const block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + const {} + } + _ => {} + } + + // async block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + async {} + } + _ => {} + } + + // gen block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + gen {} + } + _ => {} + } + + // try block + match (lhs, rhs) { + (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + try {} + } + _ => {} + } +} + +fn main() {} From fe938371308ca65d50047c5516c8467beec5a25f Mon Sep 17 00:00:00 2001 From: AsthaMishra Date: Sat, 5 Sep 2026 23:56:56 +0000 Subject: [PATCH 3/3] more test cases added + fix added for empty blocks violating max_width --- src/matches.rs | 4 +- tests/source/issue_6848_style_edition_2024.rs | 75 +++++++++++++------ tests/source/issue_6848_style_edition_2027.rs | 75 +++++++++++++------ tests/target/issue_6848_style_edition_2024.rs | 58 +++++++++++++- tests/target/issue_6848_style_edition_2027.rs | 61 ++++++++++++++- 5 files changed, 216 insertions(+), 57 deletions(-) diff --git a/src/matches.rs b/src/matches.rs index 8a689d0beae..b6bc7b4b4ad 100644 --- a/src/matches.rs +++ b/src/matches.rs @@ -535,9 +535,11 @@ pub(crate) fn rewrite_match_body( body_shape.width, ); + let enforce_empty_block_width = + is_empty_block && context.config.style_edition() >= StyleEdition::Edition2027; match rewrite { Ok(ref body_str) - if is_block + if (is_block && !enforce_empty_block_width) || (!body_str.contains('\n') && unicode_str_width(body_str) <= body_shape.width) => { diff --git a/tests/source/issue_6848_style_edition_2024.rs b/tests/source/issue_6848_style_edition_2024.rs index 3ce14d8ec59..96dbd76415e 100644 --- a/tests/source/issue_6848_style_edition_2024.rs +++ b/tests/source/issue_6848_style_edition_2024.rs @@ -7,9 +7,18 @@ enum ExampleTypeX { VariantAlphaSampleXYZ, VariantBetaXYZ, + VariantABCD, + VariantABCDE, + VariantABCDEF, + VariantABCDEFG, + VariantABCDEFGH, + VariantABCDEFGHI, + VariantABCDEFGHIJ, + VariantABCDEFGHIJK, } fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + //unsafe block match (lhs, rhs) { ( ExampleTypeX::VariantAlphaSampleXYZ, @@ -19,45 +28,63 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { _ => {} } + match (lhs, rhs) { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCD, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFGHIJKL, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFGHIJKLMNO, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFHGHI, ExampleTypeX::VariantBetaXYZ) => 'a: {}, + _ => {} + } + // const block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => const { - } + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => const {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => const {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => const {}, _ => {} - } - + } + // async block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => async { - }, + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => async {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => async {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => async {}, _ => {} } - // gen block + // gen block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => gen { - }, + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => gen {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => gen {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => gen {}, _ => {} } // try block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => try { - }, + //1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => try {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => try {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => try {}, _ => {} } } -fn main() {} \ No newline at end of file +fn main() {} diff --git a/tests/source/issue_6848_style_edition_2027.rs b/tests/source/issue_6848_style_edition_2027.rs index 8cfcfd5efe1..3ac29f2f81d 100644 --- a/tests/source/issue_6848_style_edition_2027.rs +++ b/tests/source/issue_6848_style_edition_2027.rs @@ -7,9 +7,18 @@ enum ExampleTypeX { VariantAlphaSampleXYZ, VariantBetaXYZ, + VariantABCD, + VariantABCDE, + VariantABCDEF, + VariantABCDEFG, + VariantABCDEFGH, + VariantABCDEFGHI, + VariantABCDEFGHIJ, + VariantABCDEFGHIJK, } fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + //unsafe block match (lhs, rhs) { ( ExampleTypeX::VariantAlphaSampleXYZ, @@ -19,45 +28,63 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { _ => {} } + match (lhs, rhs) { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCD, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFGHIJKL, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFGHIJKLMNO, ExampleTypeX::VariantBetaXYZ) => unsafe { non_empty_block()}, + (ExampleTypeX::VariantABCDEFHGHI, ExampleTypeX::VariantBetaXYZ) => 'a: {}, + _ => {} + } + // const block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => const { - } + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => const {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => const {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => const {}, _ => {} - } - + } + // async block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => async { - }, + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => async {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => async {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => async {}, _ => {} } - // gen block + // gen block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => gen { - }, + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => gen {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => gen {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => gen {}, _ => {} } // try block match (lhs, rhs) { - ( - ExampleTypeX::VariantAlphaSampleXYZ, - ExampleTypeX::VariantBetaXYZ, - ) => try { - }, + //1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => try {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => try {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => try {}, _ => {} } } -fn main() {} \ No newline at end of file +fn main() {} diff --git a/tests/target/issue_6848_style_edition_2024.rs b/tests/target/issue_6848_style_edition_2024.rs index 5d0231dde9a..ddcbc933747 100644 --- a/tests/target/issue_6848_style_edition_2024.rs +++ b/tests/target/issue_6848_style_edition_2024.rs @@ -7,18 +7,53 @@ enum ExampleTypeX { VariantAlphaSampleXYZ, VariantBetaXYZ, + VariantABCD, + VariantABCDE, + VariantABCDEF, + VariantABCDEFG, + VariantABCDEFGH, + VariantABCDEFGHI, + VariantABCDEFGHIJ, + VariantABCDEFGHIJK, } fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + //unsafe block match (lhs, rhs) { (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => unsafe { }, _ => {} } + match (lhs, rhs) { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCD, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe { + non_empty_block() + }, + (ExampleTypeX::VariantABCDEFGHIJKL, ExampleTypeX::VariantBetaXYZ) => unsafe { + non_empty_block() + }, + ( + ExampleTypeX::VariantABCDEFGHIJKLMNO, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { non_empty_block() }, + (ExampleTypeX::VariantABCDEFHGHI, ExampleTypeX::VariantBetaXYZ) => 'a: {} + _ => {} + } + // const block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => const {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => const {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => { const {} } _ => {} @@ -26,7 +61,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // async block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => async {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => async {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => { async {} } _ => {} @@ -34,7 +74,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // gen block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => gen {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => gen {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => { gen {} } _ => {} @@ -42,7 +87,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // try block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + //1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => try {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => try {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => { try {} } _ => {} diff --git a/tests/target/issue_6848_style_edition_2027.rs b/tests/target/issue_6848_style_edition_2027.rs index c5cb718a972..18421835b89 100644 --- a/tests/target/issue_6848_style_edition_2027.rs +++ b/tests/target/issue_6848_style_edition_2027.rs @@ -7,9 +7,18 @@ enum ExampleTypeX { VariantAlphaSampleXYZ, VariantBetaXYZ, + VariantABCD, + VariantABCDE, + VariantABCDEF, + VariantABCDEFG, + VariantABCDEFGH, + VariantABCDEFGHI, + VariantABCDEFGHIJ, + VariantABCDEFGHIJK, } fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { + //unsafe block match (lhs, rhs) { ( ExampleTypeX::VariantAlphaSampleXYZ, @@ -18,9 +27,38 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { _ => {} } + match (lhs, rhs) { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCD, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => unsafe {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => + unsafe {}, + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => unsafe { + non_empty_block() + }, + ( + ExampleTypeX::VariantABCDEFGHIJKL, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { non_empty_block() }, + ( + ExampleTypeX::VariantABCDEFGHIJKLMNO, + ExampleTypeX::VariantBetaXYZ, + ) => unsafe { non_empty_block() }, + (ExampleTypeX::VariantABCDEFHGHI, ExampleTypeX::VariantBetaXYZ) => + 'a: {} + _ => {} + } + // const block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => const {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => const {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => { const {} } _ => {} @@ -28,7 +66,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // async block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDE, ExampleTypeX::VariantBetaXYZ) => async {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEF, ExampleTypeX::VariantBetaXYZ) => async {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => { async {} } _ => {} @@ -36,7 +79,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // gen block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + // 1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => gen {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => gen {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => { gen {} } _ => {} @@ -44,7 +92,12 @@ fn demo(lhs: ExampleTypeX, rhs: ExampleTypeX) { // try block match (lhs, rhs) { - (ExampleTypeX::VariantAlphaSampleXYZ, ExampleTypeX::VariantBetaXYZ) => { + //1 char below the max_width limit + (ExampleTypeX::VariantABCDEFG, ExampleTypeX::VariantBetaXYZ) => try {}, + // everything properly fits on 1 line at exactly the max_width limit + (ExampleTypeX::VariantABCDEFGH, ExampleTypeX::VariantBetaXYZ) => try {}, + // 1 char over the max_width limit + (ExampleTypeX::VariantABCDEFGHI, ExampleTypeX::VariantBetaXYZ) => { try {} } _ => {}