Make sibling node comparison work for all lists

Author: andrewbranch

src/compiler/emitter.ts

@@ -4514,23 +4514,18 @@ namespace ts {
                 return false;
             }
 
-            if (isImportSpecifier(previousNode)) {
-                const getNextSpecifier = (node: ImportSpecifier): ImportSpecifier | undefined => {
-                    if (!node.parent) {
-                        return;
-                    }
-                    for (const sibling of node.parent.elements) {
-                        if (node.pos < sibling.pos) {
-                            return sibling;
-                        }
-                    }
-                };
+            if (nextNode.pos < previousNode.end) {
+                return false;
+            }
 
-                // Get the next specifier and compare against nextNode. If they are not equal, nodes have been rearranged and positions cannot be compared.
-                const nextSpecifier = getNextSpecifier(previousNode);
-                if (nextSpecifier && nextSpecifier !== nextNode) {
-                    return false;
-                }
+            if (!previousNode.parent || !nextNode.parent) {
+                const previousParent = getOriginalNode(previousNode).parent;
+                return previousParent && previousParent === getOriginalNode(nextNode).parent;
+            }
+
+            // Get the next specifier and compare against nextNode. If they are not equal, nodes have been rearranged and positions cannot be compared.
+            if (!nodeIsFirstNodeAtOrAfterPosition(currentSourceFile!, getOriginalNode(nextNode), previousNode.end)) {
+            return false;
             }
 
             return true;

src/compiler/utilities.ts

@@ -7098,4 +7098,37 @@ namespace ts {
             current = child;
         }
     }
+
+    export function nodeIsFirstNodeAtOrAfterPosition(sourceFile: SourceFile, node: Node, position: number): boolean {
+        if (node.pos === position) return true;
+        if (node.pos < position) return false;
+        let current: Node = sourceFile;
+        let next: Node | undefined;
+        const getContainingChild = (child: Node) => {
+            if (child.pos <= position && (position < child.end || (position === child.end && (child.kind === SyntaxKind.EndOfFileToken)))) {
+                return child;
+            }
+            else if (!next && child.pos > position) {
+                next = child;
+            }
+        };
+        while (true) {
+            const child = isSourceFileJS(sourceFile) && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
+            if (child === node || next === node) {
+                return true;
+            }
+            if (!child) {
+                if (next) {
+                    // 'position' fell between two nodes (e.g., the comma between
+                    // two ImportSpecifiers). Instead of stopping at the parent node,
+                    // shift forward to the next node and continue searching there.
+                    position = next.pos;
+                    next = undefined;
+                    continue;
+                }
+                return false;
+            }
+            current = child;
+        }
+    }
 }