fix: formatter use newline interference (#7431)

## Description

Fixes #7434.


## The Problem

1. Original code: `use utils::{IssuanceParams};`
  - We have have `use`, `utils`, `::`, `{`, `IssuanceParams`,`}`, ;
  - Total: 7 leaf spans (tokens)
2. Formatted code: `use utils::IssuanceParams;` (braces removed)
  - We have `use`, `utils`, `::`, `IssuanceParams`, `;`
  - Total: 5 leaf spans (no `{` and `}`tokens)
3. handle_newlines() zips unformatted and formatted spans together:
for (unformatted_span, formatted_span) in
    unformatted_spans.zip(formatted_spans)
4. After the use statement, spans are MISALIGNED


This PR fixes that by actually tracking removed spans for handling the
misalignment.

Author: kayagokalp

swayfmt/src/formatter/mod.rs

@@ -16,13 +16,17 @@ use sway_types::{SourceEngine, Spanned};
 
 pub(crate) mod shape;
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Formatter {
     pub source_engine: Arc<SourceEngine>,
     pub shape: Shape,
     pub config: Config,
     pub comments_context: CommentsContext,
     pub experimental: ExperimentalFeatures,
+    /// Tracks spans that were removed during formatting (e.g., braces from single-element imports).
+    /// Maps: unformatted_byte_position -> number_of_bytes_removed
+    /// This allows handle_newlines() to adjust span mapping when AST structure changes.
+    pub(crate) removed_spans: Vec<(usize, usize)>,
 }
 
 pub type FormattedCode = String;

swayfmt/src/items/item_use/mod.rs

@@ -68,6 +68,13 @@ impl Format for UseTree {
                     && !formatter.shape.code_line.line_style.is_multiline()
                 {
                     // we can have: path::{single_import}
+                    // Record that we're removing the opening and closing braces
+                    // Format: (byte_position, bytes_removed)
+                    let open_brace_pos = imports.span().start();
+                    let close_brace_pos = imports.span().end() - 1;
+                    formatter.removed_spans.push((open_brace_pos, 1)); // Remove '{'
+                    formatter.removed_spans.push((close_brace_pos, 1)); // Remove '}'
+
                     if let Some(single_import) = &imports.inner.final_value_opt {
                         single_import.format(formatted_code, formatter)?;
                     }
@@ -77,6 +84,13 @@ impl Format for UseTree {
                 {
                     // but we can also have: path::{single_import,}
                     // note that in the case of multiline we want to keep the trailing comma
+                    let open_brace_pos = imports.span().start();
+                    let close_brace_pos = imports.span().end() - 1;
+                    formatter.removed_spans.push((open_brace_pos, 1)); // Remove '{'
+                                                                       // Also removing the trailing comma (1 byte) before the '}'
+                    formatter.removed_spans.push((close_brace_pos - 1, 1)); // Remove ','
+                    formatter.removed_spans.push((close_brace_pos, 1)); // Remove '}'
+
                     let single_import = &imports
                         .inner
                         .value_separator_pairs

swayfmt/src/items/item_use/tests.rs

@@ -70,3 +70,44 @@ fmt_test_item!(single_import_multiline_with_braces_with_trailing_comma      "use
 };",
           braced_single_import      "use std::tx::{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,};"
 );
+
+#[test]
+fn single_import_with_braces_preserves_following_item() {
+    // Regression test for: https://github.com/FuelLabs/sway/issues/7434
+    use crate::Formatter;
+    use indoc::indoc;
+
+    let unformatted = indoc! {r#"
+        contract;
+        use utils::{IssuanceParams};
+        pub struct BridgeRegisteredEvent {
+            pub bridge_name: String,
+            pub bridge_id: b256,
+        }
+    "#};
+
+    let expected = indoc! {r#"
+        contract;
+        use utils::IssuanceParams;
+        pub struct BridgeRegisteredEvent {
+            pub bridge_name: String,
+            pub bridge_id: b256,
+        }
+    "#};
+
+    let mut formatter = Formatter::default();
+    let first_formatted = Formatter::format(&mut formatter, unformatted.into()).unwrap();
+
+    // The critical assertion: "pub struct BridgeRegisteredEvent" should stay on one line
+    assert!(
+        !first_formatted.contains("pub struct\n"),
+        "Bug regression: struct name was split from 'pub struct' keyword"
+    );
+
+    assert_eq!(first_formatted, expected);
+
+    // Ensure idempotency
+    let second_formatted =
+        Formatter::format(&mut formatter, first_formatted.as_str().into()).unwrap();
+    assert_eq!(second_formatted, first_formatted);
+}

swayfmt/src/utils/map/newline.rs

@@ -130,6 +130,7 @@ pub fn handle_newlines(
         formatted_code,
         unformatted_input,
         newline_threshold,
+        &formatter.removed_spans,
     )?;
     Ok(())
 }
@@ -162,6 +163,7 @@ fn add_newlines(
     formatted_code: &mut FormattedCode,
     unformatted_code: Arc<str>,
     newline_threshold: usize,
+    removed_spans: &[(usize, usize)],
 ) -> Result<(), FormatterError> {
     let mut unformatted_newline_spans = unformatted_module.leaf_spans();
     let mut formatted_newline_spans = formatted_module.leaf_spans();
@@ -185,6 +187,29 @@ fn add_newlines(
     let mut previous_formatted_newline_span = formatted_newline_spans
         .first()
         .ok_or(FormatterError::NewlineSequenceError)?;
+    // Check if AST structure changed during formatting (e.g., braces removed from imports)
+    if !removed_spans.is_empty() {
+        // When AST structure changed, directly map newline positions from unformatted to formatted
+        newline_map.iter().try_fold(
+            0_i64,
+            |mut offset, (newline_span, newline_sequence)| -> Result<i64, FormatterError> {
+                let formatted_pos =
+                    map_unformatted_to_formatted_position(newline_span.end, removed_spans);
+
+                offset += insert_after_span(
+                    calculate_offset(formatted_pos, offset),
+                    newline_sequence.clone(),
+                    formatted_code,
+                    newline_threshold,
+                )?;
+
+                Ok(offset)
+            },
+        )?;
+
+        return Ok(());
+    }
+
     for (unformatted_newline_span, formatted_newline_span) in unformatted_newline_spans
         .iter()
         .skip(1)
@@ -387,6 +412,25 @@ fn first_newline_sequence_in_span(
     None
 }
 
+/// Maps an unformatted byte position to the corresponding formatted byte position
+/// by accounting for removed spans during formatting.
+///
+/// For example, if we removed 2 bytes at position 22 (e.g., '{' and '}'),
+/// then position 40 in unformatted maps to position 38 in formatted.
+fn map_unformatted_to_formatted_position(
+    unformatted_pos: usize,
+    removed_spans: &[(usize, usize)],
+) -> usize {
+    // Sum all bytes removed before this position
+    let total_removed = removed_spans
+        .iter()
+        .filter(|(removed_pos, _)| *removed_pos < unformatted_pos)
+        .map(|(_, removed_count)| removed_count)
+        .sum::<usize>();
+
+    unformatted_pos.saturating_sub(total_removed)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::utils::map::{byte_span::ByteSpan, newline::first_newline_sequence_in_span};