Fix organize imports inserting extra blank lines

src/compiler/emitter.ts

@@ -919,7 +919,7 @@ namespace ts {
         let containerEnd = -1;
         let declarationListContainerEnd = -1;
         let currentLineMap: readonly number[] | undefined;
-        let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number}[] | undefined;
+        let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number }[] | undefined;
         let hasWrittenComment = false;
         let commentsDisabled = !!printerOptions.removeComments;
         let lastNode: Node | undefined;
@@ -4488,12 +4488,12 @@ namespace ts {
                     // JsxText will be written with its leading whitespace, so don't add more manually.
                     return 0;
                 }
-                else if (!nodeIsSynthesized(previousNode) && !nodeIsSynthesized(nextNode) && previousNode.parent === nextNode.parent) {
+                else if (siblingNodePositionsAreComparable(previousNode, nextNode)) {
                     if (preserveSourceNewlines) {
                         return getEffectiveLines(
                             includeComments => getLinesBetweenRangeEndAndRangeStart(
-                                previousNode,
-                                nextNode,
+                                getOriginalNode(previousNode),
+                                getOriginalNode(nextNode),
                                 currentSourceFile!,
                                 includeComments));
                     }
@@ -4509,6 +4509,28 @@ namespace ts {
             return format & ListFormat.MultiLine ? 1 : 0;
         }
 
+        function siblingNodePositionsAreComparable(previousNode: Node, nextNode: Node) {
+            if (previousNode.kind === SyntaxKind.NotEmittedStatement && nextNode.kind === SyntaxKind.NotEmittedStatement) {
+                return false;
+            }
+            if (nodeIsSynthesized(previousNode) || nodeIsSynthesized(nextNode)) {
+                return false;
+            }
+
+            // Get the position next node and compare against nextNode. If they are not equal, nodes have been rearranged and positions cannot be compared.
+            const originalNextNode = getNodeAtPosition(currentSourceFile!, previousNode.end + 1);
+            if (originalNextNode.pos !== nextNode.pos) {
+                return false;
+            }
+
+            if (!previousNode.parent || !nextNode.parent) {
+                const previousParent = getOriginalNode(previousNode).parent;
+                return previousParent && previousParent === getOriginalNode(nextNode).parent;
+            }
+
+            return nextNode.pos >= previousNode.end;
+        }
+
         function getClosingLineTerminatorCount(parentNode: TextRange, children: readonly Node[], format: ListFormat): number {
             if (format & ListFormat.PreserveLines || preserveSourceNewlines) {
                 if (format & ListFormat.PreferNewLine) {
@@ -4659,7 +4681,7 @@ namespace ts {
                     const text = isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode(textSourceNode);
                     return jsxAttributeEscape ? `"${escapeJsxAttributeString(text)}"` :
                         neverAsciiEscape || (getEmitFlags(node) & EmitFlags.NoAsciiEscaping) ? `"${escapeString(text)}"` :
-                        `"${escapeNonAsciiString(text)}"`;
+                            `"${escapeNonAsciiString(text)}"`;
                 }
                 else {
                     return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);

src/compiler/program.ts

@@ -2354,22 +2354,6 @@ namespace ts {
                 }
             }
 
-            /** Returns a token if position is in [start-of-leading-trivia, end), includes JSDoc only in JS files */
-            function getNodeAtPosition(sourceFile: SourceFile, position: number): Node {
-                let current: Node = sourceFile;
-                const getContainingChild = (child: Node) => {
-                    if (child.pos <= position && (position < child.end || (position === child.end && (child.kind === SyntaxKind.EndOfFileToken)))) {
-                        return child;
-                    }
-                };
-                while (true) {
-                    const child = isJavaScriptFile && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
-                    if (!child) {
-                        return current;
-                    }
-                    current = child;
-                }
-            }
         }
 
         function getLibFileFromReference(ref: FileReference) {

src/compiler/utilities.ts

@@ -7081,4 +7081,21 @@ namespace ts {
             return false;
         }
     }
+
+    /** Returns a token if position is in [start-of-leading-trivia, end), includes JSDoc only in JS files */
+    export function getNodeAtPosition(sourceFile: SourceFile, position: number): Node {
+        let current: Node = sourceFile;
+        const getContainingChild = (child: Node) => {
+            if (child.pos <= position && (position < child.end || (position === child.end && (child.kind === SyntaxKind.EndOfFileToken)))) {
+                return child;
+            }
+        };
+        while (true) {
+            const child = isSourceFileJS(sourceFile) && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
+            if (!child) {
+                return current;
+            }
+            current = child;
+        }
+    }
 }

tests/cases/fourslash/organizeImports1.ts

@@ -0,0 +1,32 @@
+/// <reference path="fourslash.ts" />
+
+// Regression test for bug #41417
+
+//// import {
+////     d, d as D,
+////     c,
+////     c as C, b,
+////     b as B, a
+//// } from './foo';
+//// import {
+////     h, h as H,
+////     g,
+////     g as G, f,
+////     f as F, e
+//// } from './foo';
+//// 
+//// console.log(a, B, b, c, C, d, D);
+//// console.log(e, f, F, g, G, H, h);
+
+verify.organizeImports(
+`import {
+    a, b,
+    b as B, c,
+    c as C, d, d as D, e, f,
+    f as F, g,
+    g as G, h, h as H
+} from './foo';
+
+console.log(a, B, b, c, C, d, D);
+console.log(e, f, F, g, G, H, h);`
+);