fix: Fix node sorting edge case related to whitespace.

Author: dsherret

src/parsing/mod.rs

@@ -2,11 +2,13 @@ mod comments;
 mod node_helpers;
 mod parser_types;
 mod parser;
+mod sorting;
 mod tokens;
 mod swc;
 
 use comments::*;
 use parser_types::*;
+use sorting::*;
 use tokens::*;
 
 pub use parser::parse;

src/parsing/parser.rs

@@ -1193,7 +1193,7 @@ fn parse_named_import_or_export_specifiers<'a>(parent: &Node<'a>, specifiers: Ve
     fn get_node_sorter<'a>(
         parent_decl: &Node,
         context: &Context<'a>,
-    ) -> Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering>> {
+    ) -> Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> std::cmp::Ordering>> {
         match parent_decl {
             Node::NamedExport(_) => get_node_sorter_from_order(context.config.export_declaration_sort_named_exports),
             Node::ImportDecl(_) => get_node_sorter_from_order(context.config.import_declaration_sort_named_imports),
@@ -5095,7 +5095,7 @@ struct ParseSeparatedValuesOptions<'a> {
     custom_single_line_separator: Option<PrintItems>,
     multi_line_options: parser_helpers::MultiLineOptions,
     force_possible_newline_at_start: bool,
-    node_sorter: Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering>>,
+    node_sorter: Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> std::cmp::Ordering>>,
 }
 
 #[inline]
@@ -5435,7 +5435,7 @@ struct ParseObjectLikeNodeOptions<'a> {
     prefer_single_line: bool,
     surround_single_line_with_spaces: bool,
     allow_blank_lines: bool,
-    node_sorter: Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering>>,
+    node_sorter: Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> std::cmp::Ordering>>,
 }
 
 fn parse_object_like_node<'a>(opts: ParseObjectLikeNodeOptions<'a>, context: &mut Context<'a>) -> PrintItems {
@@ -6789,54 +6789,3 @@ fn get_parsed_semi_colon(option: SemiColons, is_trailing: bool, is_multi_line: &
 fn create_span_data(lo: BytePos, hi: BytePos) -> Span {
     Span { lo, hi, ctxt: Default::default() }
 }
-
-/* sort functions */
-
-fn get_node_sorter_from_order<'a>(order: SortOrder) -> Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering>> {
-    match order {
-        SortOrder::Maintain => None,
-        SortOrder::CaseInsensitive => Some(sort_by_text_case_insensitive()),
-        SortOrder::CaseSensitive => Some(sort_by_text_case_sensitive()),
-    }
-}
-
-fn sort_by_text_case_insensitive<'a>() -> Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering> {
-    Box::new(|a, b, context| {
-        if let Some(a) = a.as_ref() {
-            if let Some(b) = b.as_ref() {
-                let case_insensitive_result = a.text(context).to_lowercase().cmp(&b.text(context).to_lowercase());
-                if case_insensitive_result == std::cmp::Ordering::Equal {
-                    a.text(context).cmp(&b.text(context)) // do a case sensitive comparison at this point
-                } else {
-                    case_insensitive_result
-                }
-            } else {
-                std::cmp::Ordering::Greater
-            }
-        } else {
-            if b.is_none() {
-                std::cmp::Ordering::Equal
-            } else {
-                std::cmp::Ordering::Less
-            }
-        }
-    })
-}
-
-fn sort_by_text_case_sensitive<'a>() -> Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &mut Context<'a>) -> std::cmp::Ordering> {
-    Box::new(|a, b, context| {
-        if let Some(a) = a.as_ref() {
-            if let Some(b) = b.as_ref() {
-                a.text(context).cmp(&b.text(context)) // do a case sensitive comparison at this point
-            } else {
-                std::cmp::Ordering::Greater
-            }
-        } else {
-            if b.is_none() {
-                std::cmp::Ordering::Equal
-            } else {
-                std::cmp::Ordering::Less
-            }
-        }
-    })
-}

src/parsing/parser_types.rs

@@ -8,6 +8,8 @@ use super::*;
 use super::super::configuration::*;
 use super::super::utils::Stack;
 
+// todo: the span_data() should be changed to span() -- This was previously based on how swc used to work
+
 pub struct Context<'a> {
     pub config: &'a Configuration,
     pub comments: CommentCollection<'a>,

src/parsing/sorting.rs

@@ -0,0 +1,111 @@
+use swc_common::{Span, Spanned};
+use std::cmp::Ordering;
+
+use super::*;
+use crate::configuration::*;
+
+pub fn get_node_sorter_from_order<'a>(order: SortOrder) -> Option<Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> Ordering>> {
+    match order {
+        SortOrder::Maintain => None,
+        SortOrder::CaseInsensitive => Some(sort_by_text_case_insensitive()),
+        SortOrder::CaseSensitive => Some(sort_by_text_case_sensitive()),
+    }
+}
+
+fn sort_by_text_case_insensitive<'a>() -> Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> Ordering> {
+    Box::new(|a, b, context| {
+        cmp_optional_nodes(a, b, context, cmp_nodes_case_insensitive)
+    })
+}
+
+fn sort_by_text_case_sensitive<'a>() -> Box<dyn Fn(&Option<Node<'a>>, &Option<Node<'a>>, &Context<'a>) -> Ordering> {
+    Box::new(|a, b, context| {
+        cmp_optional_nodes(a, b, context, cmp_nodes_case_sensitive)
+    })
+}
+
+fn cmp_optional_nodes<'a>(
+    a: &Option<Node<'a>>,
+    b: &Option<Node<'a>>,
+    context: &Context<'a>,
+    cmp_func: impl Fn(&dyn Ranged, &dyn Ranged, &Context<'a>) -> Ordering,
+) -> Ordering {
+    if let Some(a) = a.as_ref() {
+        if let Some(b) = b.as_ref() {
+            cmp_nodes(&a, &b, context, cmp_func)
+        } else {
+            Ordering::Greater
+        }
+    } else {
+        if b.is_none() {
+            Ordering::Equal
+        } else {
+            Ordering::Less
+        }
+    }
+}
+
+fn cmp_nodes<'a>(
+    a: &Node<'a>,
+    b: &Node<'a>,
+    context: &Context<'a>,
+    cmp_func: impl Fn(&dyn Ranged, &dyn Ranged, &Context<'a>) -> Ordering,
+) -> Ordering {
+    let a_nodes = get_comparison_nodes(a);
+    let b_nodes = get_comparison_nodes(b);
+
+    for (i, a) in a_nodes.iter().enumerate() {
+        if let Some(b) = b_nodes.get(i) {
+            let cmp_result = cmp_func(a, b, context);
+            if cmp_result != Ordering::Equal {
+                return cmp_result;
+            }
+        } else {
+            return Ordering::Greater;
+        }
+    }
+
+    if a_nodes.len() < b_nodes.len() {
+        Ordering::Less
+    } else {
+        Ordering::Equal
+    }
+}
+
+fn get_comparison_nodes<'a>(node: &Node<'a>) -> Vec<Span> {
+    match node {
+        Node::ImportNamedSpecifier(node) => {
+            if let Some(imported) = &node.imported {
+                vec![imported.span(), node.local.span()]
+            } else {
+                vec![node.local.span()]
+            }
+        },
+        Node::ExportNamedSpecifier(node) => {
+            if let Some(exported) = &node.exported {
+                vec![node.orig.span(), exported.span()]
+            } else {
+                vec![node.orig.span()]
+            }
+        },
+        _ => {
+            #[cfg(debug_assertions)]
+            unimplemented!("Not implemented sort node.");
+            #[cfg(not(debug_assertions))]
+            vec![node.span_data()]
+        }
+    }
+}
+
+fn cmp_nodes_case_sensitive<'a>(a: &dyn Ranged, b: &dyn Ranged, context: &Context) -> Ordering {
+    a.text(context).cmp(&b.text(context))
+}
+
+fn cmp_nodes_case_insensitive<'a>(a: &dyn Ranged, b: &dyn Ranged, context: &Context) -> Ordering {
+    let case_insensitive_result = a.text(context).to_lowercase().cmp(&b.text(context).to_lowercase());
+    if case_insensitive_result == Ordering::Equal {
+        cmp_nodes_case_sensitive(a, b, context)
+    } else {
+        case_insensitive_result
+    }
+}

tests/specs/declarations/export/ExportNamedDeclaration_All.txt

@@ -77,3 +77,19 @@ export { a } from "test";
 export {
     b, // test
 } from "test";
+
+== should sort the exports in alphabetical order ==
+export { c, B, a, f2, f, f1} from "a";
+export { b as a, a as b } from "test";
+export { a as ab, a as aa } from "test";
+export { a as   ab, a as aa } from "test";
+export { a as   ab, a } from "test";
+export { a, a as   ab } from "test";
+
+[expect]
+export { a, B, c, f, f1, f2 } from "a";
+export { a as b, b as a } from "test";
+export { a as aa, a as ab } from "test";
+export { a as aa, a as ab } from "test";
+export { a, a as ab } from "test";
+export { a, a as ab } from "test";

tests/specs/declarations/import/ImportDeclaration_All.txt

@@ -89,9 +89,19 @@ import {
 
 == should sort the imports in alphabetical order ==
 import { d, c, B, a, E, f2, f, f1} from "test";
+import { b as a, a as b } from "test";
+import { a as ab, a as aa } from "test";
+import { a as   ab, a as aa } from "test";
+import { a as   ab, a } from "test";
+import { a, a as   ab } from "test";
 
 [expect]
 import { a, B, c, d, E, f, f1, f2 } from "test";
+import { a as b, b as a } from "test";
+import { a as aa, a as ab } from "test";
+import { a as aa, a as ab } from "test";
+import { a, a as ab } from "test";
+import { a, a as ab } from "test";
 
 == should prefer single line by default ==
 import {