Change detection in organizeImports

src/compiler/types.ts

@@ -10094,10 +10094,12 @@ export interface UserPreferences {
     readonly organizeImportsNumericCollation?: boolean;
     readonly organizeImportsAccentCollation?: boolean;
     readonly organizeImportsCaseFirst?: "upper" | "lower" | false;
-    readonly organizeImportsTypeOrder?: "first" | "last" | "inline";
+    readonly organizeImportsTypeOrder?: OrganizeImportsTypeOrder;
     readonly excludeLibrarySymbolsInNavTo?: boolean;
 }
 
+export type OrganizeImportsTypeOrder = "first" | "last" | "inline";
+
 /** Represents a bigint literal value without requiring bigint support */
 export interface PseudoBigInt {
     negative: boolean;

src/server/protocol.ts

@@ -6,6 +6,7 @@ import type {
     HighlightSpanKind,
     InteractiveRefactorArguments,
     MapLike,
+    OrganizeImportsTypeOrder,
     OutliningSpanKind,
     OutputFile,
     PluginImport,
@@ -3649,7 +3650,7 @@ export interface UserPreferences {
      *
      * Default: `last`
      */
-    readonly organizeImportsTypeOrder?: "last" | "first" | "inline";
+    readonly organizeImportsTypeOrder?: OrganizeImportsTypeOrder;
 
     /**
      * Indicates whether {@link ReferencesResponseItem.lineText} is supported.

src/services/codefixes/importFixes.ts

@@ -3,6 +3,7 @@ import {
     AnyImportOrRequireStatement,
     AnyImportSyntax,
     arrayFrom,
+    arrayIsSorted,
     CancellationToken,
     cast,
     changeAnyExtension,
@@ -12,6 +13,7 @@ import {
     combine,
     compareBooleans,
     compareNumberOfDirectorySeparators,
+    Comparer,
     compareValues,
     Comparison,
     CompilerOptions,
@@ -58,11 +60,13 @@ import {
     hostGetCanonicalFileName,
     Identifier,
     ImportClause,
+    ImportDeclaration,
     ImportEqualsDeclaration,
     importFromModuleSpecifier,
     ImportKind,
     importNameElisionDisabled,
     ImportsNotUsedAsValues,
+    ImportSpecifier,
     insertImports,
     InternalSymbolName,
     isExternalModule,
@@ -107,6 +111,7 @@ import {
     nodeIsMissing,
     ObjectBindingPattern,
     OrganizeImports,
+    OrganizeImportsTypeOrder,
     PackageJsonImportFilter,
     Path,
     pathContainsNodeModules,
@@ -123,7 +128,6 @@ import {
     skipAlias,
     some,
     sort,
-    SortKind,
     SourceFile,
     stableSort,
     startsWith,
@@ -1400,11 +1404,21 @@ function promoteFromTypeOnly(
     switch (aliasDeclaration.kind) {
         case SyntaxKind.ImportSpecifier:
             if (aliasDeclaration.isTypeOnly) {
-                const sortKind = OrganizeImports.detectImportSpecifierSorting(aliasDeclaration.parent.elements, preferences);
-                if (aliasDeclaration.parent.elements.length > 1 && sortKind) {
+                if (aliasDeclaration.parent.elements.length > 1) {
                     const newSpecifier = factory.updateImportSpecifier(aliasDeclaration, /*isTypeOnly*/ false, aliasDeclaration.propertyName, aliasDeclaration.name);
-                    const comparer = OrganizeImports.getOrganizeImportsComparer(preferences, sortKind === SortKind.CaseInsensitive);
-                    const insertionIndex = OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, comparer, preferences);
+                    const { comparersToTest, typeOrdersToTest } = OrganizeImports.getDetectionLists(preferences);
+                    let specifierComparer = OrganizeImports.getOrganizeImportsSpecifierComparer(preferences, comparersToTest[0]);
+
+                    if (typeof preferences.organizeImportsIgnoreCase !== "boolean" || !preferences.organizeImportsTypeOrder) {
+                        const importDecl: ImportDeclaration[] = [aliasDeclaration.parent.parent.parent];
+                        const namedImportSort = OrganizeImports.detectNamedImportOrganizationBySort(importDecl, comparersToTest, typeOrdersToTest);
+                        if (namedImportSort) {
+                            const { namedImportComparer, typeOrder } = namedImportSort;
+                            specifierComparer = OrganizeImports.getOrganizeImportsSpecifierComparer({ organizeImportsTypeOrder: typeOrder }, namedImportComparer);
+                        }
+                    }
+
+                    const insertionIndex = OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, specifierComparer);
                     if (insertionIndex !== aliasDeclaration.parent.elements.indexOf(aliasDeclaration)) {
                         changes.delete(sourceFile, aliasDeclaration);
                         changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
@@ -1446,8 +1460,10 @@ function promoteFromTypeOnly(
         if (convertExistingToTypeOnly) {
             const namedImports = tryCast(importClause.namedBindings, isNamedImports);
             if (namedImports && namedImports.elements.length > 1) {
+                const { comparersToTest, typeOrdersToTest } = OrganizeImports.getDetectionLists(preferences);
+                const sortState = OrganizeImports.detectNamedImportOrganizationBySort([importClause.parent], comparersToTest, typeOrdersToTest);
                 if (
-                    OrganizeImports.detectImportSpecifierSorting(namedImports.elements, preferences) &&
+                    (!sortState || sortState.isSorted) &&
                     aliasDeclaration.kind === SyntaxKind.ImportSpecifier &&
                     namedImports.elements.indexOf(aliasDeclaration) !== 0
                 ) {
@@ -1497,21 +1513,25 @@ function doAddExistingFix(
         // - if the user preference is explicit, use that
         // - otherwise, if there are enough existing import specifiers in this import to detect unambiguously, use that
         // - otherwise, detect from other imports in the file
-        let ignoreCaseForSorting: boolean | undefined;
-        if (typeof preferences.organizeImportsIgnoreCase === "boolean") {
-            ignoreCaseForSorting = preferences.organizeImportsIgnoreCase;
-        }
-        else if (existingSpecifiers) {
-            const targetImportSorting = OrganizeImports.detectImportSpecifierSorting(existingSpecifiers, preferences);
-            if (targetImportSorting !== SortKind.Both) {
-                ignoreCaseForSorting = targetImportSorting === SortKind.CaseInsensitive;
+        // let ignoreCaseForSorting: boolean | undefined;
+        let specifierComparer: Comparer<ImportSpecifier> = OrganizeImports.getOrganizeImportsSpecifierComparer(preferences);
+        const { comparersToTest, typeOrdersToTest } = OrganizeImports.getDetectionLists(preferences);
+        let namedImportComparer = comparersToTest[0];
+        let typeOrder: OrganizeImportsTypeOrder | undefined = typeOrdersToTest[0];
+        let isSorted: boolean | undefined;
+
+        if (existingSpecifiers && (typeof preferences.organizeImportsIgnoreCase !== "boolean" || !preferences.organizeImportsTypeOrder)) {
+            const moduleSpecifiersDecl: ImportDeclaration[] = [clause.parent];
+            const namedImportSort = OrganizeImports.detectNamedImportOrganizationBySort(moduleSpecifiersDecl, comparersToTest, typeOrdersToTest);
+            if (namedImportSort) {
+                ({ namedImportComparer, typeOrder, isSorted } = namedImportSort);
+                specifierComparer = OrganizeImports.getOrganizeImportsSpecifierComparer({ organizeImportsTypeOrder: typeOrder }, namedImportComparer);
             }
         }
-        if (ignoreCaseForSorting === undefined) {
-            ignoreCaseForSorting = OrganizeImports.detectSorting(sourceFile, preferences) === SortKind.CaseInsensitive;
+        else {
+            isSorted = existingSpecifiers ? arrayIsSorted(existingSpecifiers, specifierComparer) : true;
         }
 
-        const comparer = OrganizeImports.getOrganizeImportsComparer(preferences, ignoreCaseForSorting);
         const newSpecifiers = stableSort(
             namedImports.map(namedImport =>
                 factory.createImportSpecifier(
@@ -1520,23 +1540,19 @@ function doAddExistingFix(
                     factory.createIdentifier(namedImport.name),
                 )
             ),
-            (s1, s2) => OrganizeImports.compareImportOrExportSpecifiers(s1, s2, comparer),
+            specifierComparer,
         );
 
         // The sorting preference computed earlier may or may not have validated that these particular
         // import specifiers are sorted. If they aren't, `getImportSpecifierInsertionIndex` will return
         // nonsense. So if there are existing specifiers, even if we know the sorting preference, we
         // need to ensure that the existing specifiers are sorted according to the preference in order
         // to do a sorted insertion.
-        const specifierSort = existingSpecifiers?.length && OrganizeImports.detectImportSpecifierSorting(existingSpecifiers, preferences);
-        if (specifierSort && !(ignoreCaseForSorting && specifierSort === SortKind.CaseSensitive)) {
+
+        // changed to check if existing specifiers are sorted
+        if (existingSpecifiers?.length && isSorted) {
             for (const spec of newSpecifiers) {
-                // Organize imports puts type-only import specifiers last, so if we're
-                // adding a non-type-only specifier and converting all the other ones to
-                // type-only, there's no need to ask for the insertion index - it's 0.
-                const insertionIndex = promoteFromTypeOnly && !spec.isTypeOnly
-                    ? 0
-                    : OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec, comparer, preferences);
+                const insertionIndex = OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec, specifierComparer);
                 changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings as NamedImports, insertionIndex);
             }
         }