diff --git a/src/items.rs b/src/items.rs
index 0e814644304..d449e4ad984 100644
--- a/src/items.rs
+++ b/src/items.rs
@@ -2500,6 +2500,7 @@ fn rewrite_fn_base(
         ret_str_len,
         fn_brace_style,
         multi_line_ret_str,
+        where_clause,
     );
 
     debug!(
@@ -2602,10 +2603,20 @@ fn rewrite_fn_base(
                 // the closing parenthesis of the param and the arrow '->' is considered.
                 let mut sig_length = result.len() + indent.width() + ret_str_len + 1;
 
-                // If there is no where-clause, take into account the space after the return type
-                // and the brace.
+                // If there is no where-clause.
                 if where_clause.predicates.is_empty() {
-                    sig_length += 2;
+                    if context.config.style_edition() >= StyleEdition::Edition2027 {
+                        let line_ending_overhead = match fn_brace_style {
+                            FnBraceStyle::NextLine => 0, // No brace to account for
+                            FnBraceStyle::SameLine => 2, // Trailing space and brace, e.g. ` {`
+                            FnBraceStyle::None => 1,     // Trailing `;`
+                        };
+                        sig_length += line_ending_overhead;
+                    } else {
+                        // Take into account the space after the return type and the brace.
+                        // 2 = ' {'
+                        sig_length += 2;
+                    }
                 }
 
                 sig_length > context.config.max_width()
@@ -2749,6 +2760,7 @@ fn rewrite_fn_base(
     force_new_line_for_brace |= ends_with_comment;
     force_new_line_for_brace |=
         is_params_multi_lined && context.config.where_single_line() && !where_clause_str.is_empty();
+
     Ok((result, ends_with_comment, force_new_line_for_brace))
 }
 
@@ -2889,6 +2901,7 @@ fn compute_budgets_for_params(
     ret_str_len: usize,
     fn_brace_style: FnBraceStyle,
     force_vertical_layout: bool,
+    where_clause: &ast::WhereClause,
 ) -> (usize, usize, Indent) {
     debug!(
         "compute_budgets_for_params {} {:?}, {}, {:?}",
@@ -2903,7 +2916,15 @@ fn compute_budgets_for_params(
         let overhead = if ret_str_len == 0 { 2 } else { 3 };
         let mut used_space = indent.width() + result.len() + ret_str_len + overhead;
         match fn_brace_style {
-            FnBraceStyle::None => used_space += 1,     // 1 = `;`
+            _ if context.config.style_edition() >= StyleEdition::Edition2027
+                && where_clause.predicates.len() > 0 =>
+            {
+                // Don't add anything to `used_space` if we have a where clause.
+                // For all `FnBraceStyle` values if we have a where cluase that can't fit
+                // on the current line it'll be written to the next line.
+                // Therefore, we don't need to account for a trailing `;` or `{}`
+            }
+            FnBraceStyle::None => used_space += 1, // 1 = `;`
             FnBraceStyle::SameLine => used_space += 2, // 2 = `{}`
             FnBraceStyle::NextLine => (),
         }
diff --git a/tests/source/issue-6539/brace_next_line.rs b/tests/source/issue-6539/brace_next_line.rs
new file mode 100644
index 00000000000..3c177ada6ac
--- /dev/null
+++ b/tests/source/issue-6539/brace_next_line.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: AlwaysNextLine
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/source/issue-6539/brace_next_line_where_single_line.rs b/tests/source/issue-6539/brace_next_line_where_single_line.rs
new file mode 100644
index 00000000000..c2c6d5460c2
--- /dev/null
+++ b/tests/source/issue-6539/brace_next_line_where_single_line.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: AlwaysNextLine
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/source/issue-6539/prefer_same_line.rs b/tests/source/issue-6539/prefer_same_line.rs
new file mode 100644
index 00000000000..b4700252893
--- /dev/null
+++ b/tests/source/issue-6539/prefer_same_line.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: PreferSameLine
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/source/issue-6539/prefer_same_line_where_single_line.rs b/tests/source/issue-6539/prefer_same_line_where_single_line.rs
new file mode 100644
index 00000000000..e90288b86f8
--- /dev/null
+++ b/tests/source/issue-6539/prefer_same_line_where_single_line.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: PreferSameLine
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/source/issue-6539/same_line_where.rs b/tests/source/issue-6539/same_line_where.rs
new file mode 100644
index 00000000000..9406ba3dc0f
--- /dev/null
+++ b/tests/source/issue-6539/same_line_where.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: SameLineWhere
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/source/issue-6539/same_line_where_single_line.rs b/tests/source/issue-6539/same_line_where_single_line.rs
new file mode 100644
index 00000000000..bd4ff0ddf36
--- /dev/null
+++ b/tests/source/issue-6539/same_line_where_single_line.rs
@@ -0,0 +1,73 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: SameLineWhere
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64 where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64, eeee: f64) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64 where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64 where T: Debug {}
+
+fn fn_with_wrapping_return_type_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64, ee: f64) -> f64 {}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug {}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(a: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64, ffff: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>>;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64 where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(self, aaa: f64, bbb: T, ccc: f64, ddd: f64, ee: f64) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64 where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(&self, aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(&self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> {}
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64 where T: Debug {}
+
+    fn method_with_wrapping_return_type_and_body<T>(aaaa: f64, bb: T, cc: f64, d: f64, e: f64) -> f64 {}
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64 where T: Debug {}
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(self) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+
+    fn method_with_everything_long_and_body<T, U, 'a>(aaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> Result<HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>, Box<dyn Error + Send + Sync + 'static>> where T: Debug + Display + Clone + Send + Sync + 'static, U: Iterator<Item = &'a T> + ExactSizeIterator {}
+}
diff --git a/tests/target/issue-6539/brace_next_line.rs b/tests/target/issue-6539/brace_next_line.rs
new file mode 100644
index 00000000000..da1a5bf1269
--- /dev/null
+++ b/tests/target/issue-6539/brace_next_line.rs
@@ -0,0 +1,242 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: AlwaysNextLine
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where
+    T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where
+    T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+{
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where
+    T: Debug,
+{
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64
+{
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where
+    T: Debug,
+{
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+// Trait methods
+pub trait Trait
+{
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where
+        T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug,
+    {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64
+    {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where
+        T: Debug,
+    {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+}
diff --git a/tests/target/issue-6539/brace_next_line_where_single_line.rs b/tests/target/issue-6539/brace_next_line_where_single_line.rs
new file mode 100644
index 00000000000..06b074dde73
--- /dev/null
+++ b/tests/target/issue-6539/brace_next_line_where_single_line.rs
@@ -0,0 +1,234 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: AlwaysNextLine
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+{
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where T: Debug
+{
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64
+{
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where T: Debug
+{
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+// Trait methods
+pub trait Trait
+{
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where T: Debug
+    {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64
+    {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where T: Debug
+    {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+}
diff --git a/tests/target/issue-6539/idempotent.rs b/tests/target/issue-6539/idempotent.rs
new file mode 100644
index 00000000000..47fa7ac84d4
--- /dev/null
+++ b/tests/target/issue-6539/idempotent.rs
@@ -0,0 +1,49 @@
+// rustfmt-style_edition: 2027
+
+// Function with the maximum length before wrapping (100 characters)
+fn a_one_hundred_column_fn_decl(aaaaaaaaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> f64;
+
+fn a_one_hundred_column_fn_decl_with_body(aaaaa: f64, bbb: f64, cc: f64, dd: f64, ee: f64) -> f64 {}
+
+fn a_ninety_nine_column_fn_decl(aaaaaaaaa: f64, bbbb: f64, cccc: f64, dddd: f64, eeee: f64) -> f64;
+
+fn a_ninety_nine_column_fn_decl_with_body(aaaaa: f64, bb: f64, cc: f64, dd: f64, ee: f64) -> f64 {}
+
+fn a_one_hundred_one_column_fn_decl(
+    aaaaaaaaaaa: f64,
+    bbb: f64,
+    ccc: f64,
+    ddd: f64,
+    eee: f64,
+) -> f64;
+
+fn a_one_hundred_one_column_fn_decl_with_body(aaaaaa: f64, bb: f64, c: f64, d: f64, e: f64) -> f64 {
+}
+
+pub trait Trait {
+    fn a_one_hundred_column_fn_decl(&self, aaaaaaa: f64, bb: f64, cc: f64, dd: f64, ee: f64) -> f64;
+
+    fn a_one_hundred_column_fn_decl_with_body(&self, aaaa: f64, bb: f64, cc: f64, dd: f64) -> f64 {}
+
+    fn a_ninety_nine_column_fn_decl(&self, aaaaaa: f64, bb: f64, cc: f64, dd: f64, ee: f64) -> f64;
+
+    fn a_ninety_nine_column_fn_decl_with_body(&self, aaa: f64, bb: f64, cc: f64, dd: f64) -> f64 {}
+
+    fn a_one_hundred_one_column_fn_decl(
+        &self,
+        aaaaaaaa: f64,
+        b: f64,
+        c: f64,
+        d: f64,
+        e: f64,
+    ) -> f64;
+
+    fn a_one_hundred_one_column_fn_decl_with_body(
+        &self,
+        aaaaa: f64,
+        b: f64,
+        c: f64,
+        d: f64,
+    ) -> f64 {
+    }
+}
diff --git a/tests/target/issue-6539/prefer_same_line.rs b/tests/target/issue-6539/prefer_same_line.rs
new file mode 100644
index 00000000000..69ac7c5c0d4
--- /dev/null
+++ b/tests/target/issue-6539/prefer_same_line.rs
@@ -0,0 +1,229 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: PreferSameLine
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where
+    T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where
+    T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+> {
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where
+    T: Debug, {
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64 {
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where
+    T: Debug, {
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator, {
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator, {
+}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where
+        T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    > {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug, {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64 {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where
+        T: Debug, {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator, {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator, {
+    }
+}
diff --git a/tests/target/issue-6539/prefer_same_line_where_single_line.rs b/tests/target/issue-6539/prefer_same_line_where_single_line.rs
new file mode 100644
index 00000000000..f45413b3f55
--- /dev/null
+++ b/tests/target/issue-6539/prefer_same_line_where_single_line.rs
@@ -0,0 +1,223 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: PreferSameLine
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+> {
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where T: Debug {
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64 {
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where T: Debug {
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator, {
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    > {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where T: Debug {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64 {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where T: Debug {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator, {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+}
diff --git a/tests/target/issue-6539/same_line_where.rs b/tests/target/issue-6539/same_line_where.rs
new file mode 100644
index 00000000000..140c41af5d6
--- /dev/null
+++ b/tests/target/issue-6539/same_line_where.rs
@@ -0,0 +1,237 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: SameLineWhere
+// rustfmt-where_single_line: false
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where
+    T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where
+    T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+> {
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where
+    T: Debug,
+{
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64 {
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where
+    T: Debug,
+{
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where
+        T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    > {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where
+        T: Debug,
+    {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64 {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where
+        T: Debug,
+    {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+}
diff --git a/tests/target/issue-6539/same_line_where_single_line.rs b/tests/target/issue-6539/same_line_where_single_line.rs
new file mode 100644
index 00000000000..a48af70af48
--- /dev/null
+++ b/tests/target/issue-6539/same_line_where_single_line.rs
@@ -0,0 +1,225 @@
+// rustfmt-style_edition: 2027
+// rustfmt-brace_style: SameLineWhere
+// rustfmt-where_single_line: true
+
+// Top-level functions
+
+// Short function
+fn short_fn(a: f64, b: f64) -> f64;
+
+// Function with wrapping return type and no where clause
+fn fn_with_long_return_type(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>;
+
+// Function with non-wrapping return type and where clause
+fn fn_with_short_where<T>(a: f64, b: T) -> f64
+where T: Debug;
+
+// Function that wraps at a simple return type
+fn fn_with_wrapping_return_type<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    cccccc: f64,
+    dddddd: f64,
+    eeee: f64,
+) -> f64;
+
+// Function that wraps at the where clause
+fn fn_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, cccccc: f64, dddddd: f64) -> f64
+where T: Debug;
+
+// Function with both wrapping return type and wrapping where clause
+fn fn_with_long_return_and_where<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Function with wrapping arguments, return type, and where clause
+fn fn_with_everything_long<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+// Same variations with bodies
+fn short_fn_with_body(a: f64, b: f64) -> f64 {}
+
+fn fn_with_long_return_type_and_body(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+> {
+}
+
+fn fn_with_short_where_and_body<T>(a: f64, b: T) -> f64
+where T: Debug {
+}
+
+fn fn_with_wrapping_return_type_and_body<T>(
+    aaaaaa: f64,
+    bbbbbb: T,
+    ccc: f64,
+    ddd: f64,
+    ee: f64,
+) -> f64 {
+}
+
+fn fn_with_wrapping_where_clause_and_body<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+where T: Debug {
+}
+
+fn fn_with_long_return_and_where_and_body<T, U, 'a>(
+    a: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+fn fn_with_everything_long_and_body<T, U, 'a>(
+    aaaa: f64,
+    bbbb: f64,
+    cccc: f64,
+    dddd: f64,
+    eeee: f64,
+    ffff: f64,
+) -> Result<
+    HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+    Box<dyn Error + Send + Sync + 'static>,
+>
+where
+    T: Debug + Display + Clone + Send + Sync + 'static,
+    U: Iterator<Item = &'a T> + ExactSizeIterator,
+{
+}
+
+// Trait methods
+pub trait Trait {
+    fn short_method(a: f64, b: f64) -> f64;
+
+    fn method_with_long_return(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >;
+
+    fn method_with_short_where<T>(&self, a: f64, b: T) -> f64
+    where T: Debug;
+
+    fn method_with_wrapping_return_type<T>(
+        self,
+        aaa: f64,
+        bbb: T,
+        ccc: f64,
+        ddd: f64,
+        ee: f64,
+    ) -> f64;
+
+    fn method_with_wrapping_where_clause<T>(aaaaaa: f64, bbbbbb: T, ccc: f64, ddd: f64) -> f64
+    where T: Debug;
+
+    fn method_with_long_return_and_where<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    fn method_with_everything_long<T, U, 'a>(
+        &self,
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator;
+
+    // Same variations with bodies
+    fn short_method_with_body(a: f64, b: f64) -> f64 {}
+
+    fn method_with_long_return_and_body(
+        &self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    > {
+    }
+
+    fn method_with_short_where_and_body<T>(&self, a: f64, b: T) -> f64
+    where T: Debug {
+    }
+
+    fn method_with_wrapping_return_type_and_body<T>(
+        aaaa: f64,
+        bb: T,
+        cc: f64,
+        d: f64,
+        e: f64,
+    ) -> f64 {
+    }
+
+    fn method_with_wrapping_where_clause_and_body<T>(aaa: f64, bb: T, cc: f64, d: f64) -> f64
+    where T: Debug {
+    }
+
+    fn method_with_long_return_and_where_and_body<T, U, 'a>(
+        self,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+
+    fn method_with_everything_long_and_body<T, U, 'a>(
+        aaaa: f64,
+        bbbb: f64,
+        cccc: f64,
+        dddd: f64,
+        eeee: f64,
+    ) -> Result<
+        HashMap<String, Vec<(SomeLongTypeName, AnotherLongTypeName, YetAnotherType)>>,
+        Box<dyn Error + Send + Sync + 'static>,
+    >
+    where
+        T: Debug + Display + Clone + Send + Sync + 'static,
+        U: Iterator<Item = &'a T> + ExactSizeIterator,
+    {
+    }
+}