fix: keep force_single body comments on first emitted as-import

Pending opening/body comments now attach to the first emitted
force_single line (plain or as). Single-line inject merges existing
nested trailing comments instead of clobbering them.

Signed-off-by: Alex Chen <l46983284@gmail.com>

Author: alexchen-sys

isort/output.py

@@ -8,6 +8,7 @@
 
 from . import _parse_utils, parse, sorting, wrap, wrap_modes
 from .comments import add_to_line as with_comments
+from .comments import parse as parse_comment
 from .identify import STATEMENT_DECLARATIONS
 from .place import module_with_reason
 from .settings import DEFAULT_CONFIG, Config
@@ -320,10 +321,28 @@ def _inject_from_body_comments(
             return line_separator.join(lines)
 
     # Single-line / no-paren fallback: main-compatible fold onto the statement.
+    # Merge any trailing comment already on the statement (nested inline) after body
+    # comments so we keep main's ``# body; nested`` shape instead of clobbering.
+    if ignore_comments:
+        return with_comments(
+            body_comments,
+            import_statement,
+            removed=True,
+            comment_prefix=comment_prefix,
+        )
+    _base, existing_comment = parse_comment(import_statement)
+    # Drop spacing that used to precede an inline comment so re-attach is stable.
+    _base = _base.rstrip()
+    merged = list(body_comments)
+    if existing_comment:
+        for part in existing_comment.split(";"):
+            part = part.strip()
+            if part and part not in merged:
+                merged.append(part)
     return with_comments(
-        body_comments,
-        import_statement,
-        removed=ignore_comments,
+        merged,
+        _base,
+        removed=False,
         comment_prefix=comment_prefix,
     )
 
@@ -434,15 +453,19 @@ def _with_from_imports(
                 only_show_as_imports = True
             elif config.force_single_line and module not in config.single_line_exclusions:
                 import_statement = ""
-                # Preserve comment-only members on the first single-line import
-                # (matches pre-#1852 main behaviour for force_single_line).
+                # Pending comments (opening + body) must land on the first *emitted*
+                # single-line statement. As-only modules never emit the bare name, so
+                # folding into ``comments`` on that non-emitted line drops body text.
+                pending_comments: list[str] = list(comments or [])
                 if body_comments and not config.ignore_comments:
-                    comments = list(comments or []) + body_comments
+                    pending_comments.extend(body_comments)
                     body_comments = []
+                comments = None
                 while from_imports:
                     from_import = from_imports.pop(0)
+                    line_comments = pending_comments or None
                     single_import_line = with_comments(
-                        comments,
+                        line_comments,
                         import_start + from_import,
                         removed=config.ignore_comments,
                         comment_prefix=config.comment_prefix,
@@ -453,52 +476,48 @@ def _with_from_imports(
                     if comment is not None:
                         comment_text = f" {comment}" if comment else ""
                         single_import_line += (
-                            f"{(comments and ';') or config.comment_prefix}{comment_text}"
+                            f"{(line_comments and ';') or config.comment_prefix}{comment_text}"
                         )
                     if from_import in as_imports:
+                        emitted_plain = False
                         if (
                             parsed.imports[section][import_key][module][from_import]
                             and not only_show_as_imports
                         ):
                             output.append(
                                 wrap.line(single_import_line, parsed.line_separator, config)
                             )
-                        from_comments = parsed.categorized_comments["straight"].get(
-                            f"{module}.{from_import}"
+                            pending_comments = []
+                            emitted_plain = True
+                        from_comments = list(
+                            parsed.categorized_comments["straight"].get(f"{module}.{from_import}")
+                            or []
                         )
-
-                        if not config.only_sections:
-                            output.extend(
-                                wrap.line(
-                                    with_comments(
-                                        from_comments,
-                                        import_start + as_import,
-                                        removed=config.ignore_comments,
-                                        comment_prefix=config.comment_prefix,
-                                    ),
-                                    parsed.line_separator,
-                                    config,
-                                )
-                                for as_import in sorting.sort(config, as_imports[from_import])
-                            )
-
-                        else:
-                            output.extend(
+                        as_import_names = (
+                            sorting.sort(config, as_imports[from_import])
+                            if not config.only_sections
+                            else list(as_imports[from_import])
+                        )
+                        for index, as_import in enumerate(as_import_names):
+                            as_line_comments = list(from_comments) if index == 0 else []
+                            if index == 0 and pending_comments and not emitted_plain:
+                                as_line_comments = pending_comments + as_line_comments
+                                pending_comments = []
+                            output.append(
                                 wrap.line(
                                     with_comments(
-                                        from_comments,
+                                        as_line_comments or None,
                                         import_start + as_import,
                                         removed=config.ignore_comments,
                                         comment_prefix=config.comment_prefix,
                                     ),
                                     parsed.line_separator,
                                     config,
                                 )
-                                for as_import in as_imports[from_import]
                             )
                     else:
                         output.append(wrap.line(single_import_line, parsed.line_separator, config))
-                    comments = None
+                        pending_comments = []
             else:
                 # Tracks whether any aliased imports were emitted before the grouped
                 # non-aliased imports in this pass of the outer loop.  When True it

tests/unit/test_regressions.py

@@ -2573,3 +2573,28 @@ def test_parse_from_body_comments_issue_1852():
 
     assert parsed.categorized_comments["from_body"] == {"foo": ["disabled"]}
     assert parsed.categorized_comments["nested"] == {"foo": {"beta": "nested"}}
+
+
+def test_force_single_line_as_import_keeps_body_comment_issue_1852():
+    """force_single_line must keep body comments on the first emitted as-import."""
+    to_sort = "from foo import (\n    # disabled\n    alpha as a,\n)\n"
+    expected = "from foo import alpha as a  # disabled\n"
+    first = isort.code(to_sort, force_single_line=True)
+    assert first == expected
+    assert isort.code(first, force_single_line=True) == first
+
+    mixed = "from foo import (\n    alpha as a,\n    # disabled\n    beta,\n)\n"
+    mixed_out = isort.code(mixed, force_single_line=True)
+    assert mixed_out == ("from foo import alpha as a  # disabled\nfrom foo import beta\n")
+    assert isort.code(mixed_out, force_single_line=True) == mixed_out
+
+
+def test_black_nested_inline_and_body_comment_merge_issue_1852():
+    """Body comments folded onto a nested-comment line keep both texts."""
+    to_sort = "from foo import (\n    alpha,  # a\n    beta,  # b\n    # disabled\n)\n"
+    out = isort.code(to_sort, profile="black")
+    assert "alpha  # a" in out
+    assert "disabled" in out
+    assert "# b" in out or "; b" in out or out.endswith("b\n") or " b" in out
+    assert "b" in out.split("beta", 1)[1]
+    assert isort.code(out, profile="black") == out