Automatically create sort groups based on newlines in organize imports

src/services/organizeImports.ts

@@ -15,16 +15,15 @@ namespace ts.OrganizeImports {
         preferences: UserPreferences,
         skipDestructiveCodeActions?: boolean
     ) {
-
         const changeTracker = textChanges.ChangeTracker.fromContext({ host, formatContext, preferences });
 
         const coalesceAndOrganizeImports = (importGroup: readonly ImportDeclaration[]) => stableSort(
             coalesceImports(removeUnusedImports(importGroup, sourceFile, program, skipDestructiveCodeActions)),
             (s1, s2) => compareImportsOrRequireStatements(s1, s2));
 
         // All of the old ImportDeclarations in the file, in syntactic order.
-        const topLevelImportDecls = sourceFile.statements.filter(isImportDeclaration);
-        organizeImportsWorker(topLevelImportDecls, coalesceAndOrganizeImports);
+        const topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(isImportDeclaration));
+        topLevelImportGroupDecls.forEach(importGroupDecl => organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports));
 
         // All of the old ExportDeclarations in the file, in syntactic order.
         const topLevelExportDecls = sourceFile.statements.filter(isExportDeclaration);
@@ -33,8 +32,8 @@ namespace ts.OrganizeImports {
         for (const ambientModule of sourceFile.statements.filter(isAmbientModule)) {
             if (!ambientModule.body) continue;
 
-            const ambientModuleImportDecls = ambientModule.body.statements.filter(isImportDeclaration);
-            organizeImportsWorker(ambientModuleImportDecls, coalesceAndOrganizeImports);
+            const ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(isImportDeclaration));
+            ambientModuleImportGroupDecls.forEach(importGroupDecl => organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports));
 
             const ambientModuleExportDecls = ambientModule.body.statements.filter(isExportDeclaration);
             organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
@@ -88,6 +87,44 @@ namespace ts.OrganizeImports {
         }
     }
 
+    function groupImportsByNewlineContiguous(sourceFile: SourceFile,importDecls: ImportDeclaration[]): ImportDeclaration[][] {
+        const groupImports: ImportDeclaration[][] = [];
+        let groupIndex = 0;
+        for (const topLevelImportDecl of importDecls) {
+            if (isStartedNewGroup(sourceFile, topLevelImportDecl)) {
+                groupIndex++;
+            }
+
+            if (!groupImports[groupIndex]) {
+                groupImports[groupIndex] = [];
+            }
+
+            groupImports[groupIndex].push(topLevelImportDecl);
+        }
+
+        return groupImports;
+    }
+
+    // a new group is created if an import includes at least two new line
+    // new line from multi-line comment doesn't count
+    function isStartedNewGroup(sourceFile: SourceFile, topLevelImportDecl: ImportDeclaration) {
+        const startPos = topLevelImportDecl.getFullStart();
+        const endPos = topLevelImportDecl.getStart();
+
+        const scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, startPos);
+
+        let numberOfNewLines = 0;
+        while (scanner.getTokenPos() < endPos) {
+            const tokenKind = scanner.scan();
+
+            if (tokenKind === SyntaxKind.NewLineTrivia) {
+                numberOfNewLines++;
+            }
+        }
+
+        return numberOfNewLines >= 2;
+    }
+
     function removeUnusedImports(oldImports: readonly ImportDeclaration[], sourceFile: SourceFile, program: Program, skipDestructiveCodeActions: boolean | undefined) {
         // As a precaution, consider unused import detection to be destructive (GH #43051)
         if (skipDestructiveCodeActions) {

tests/baselines/reference/organizeImports/TopLevelAndAmbientModule.ts

@@ -17,7 +17,6 @@ D();
 
 // ==ORGANIZED==
 
-import "lib";
 import D from "lib";
 
 declare module "mod" {
@@ -26,5 +25,6 @@ declare module "mod" {
     function F(f1: {} = F1, f2: {} = F2) {}
 }
 
+import "lib";
 
 D();

tests/cases/fourslash/organizeImportsGroup_CommentInNewline.ts

@@ -0,0 +1,21 @@
+/// <reference path="fourslash.ts" />
+
+////// polyfill
+////import c from "C";
+////// not polyfill
+////import d from "D";
+////import a from "A";
+////import b from "B";
+////
+////console.log(a, b, c, d)
+
+verify.organizeImports(
+`// polyfill
+import c from "C";
+// not polyfill
+import a from "A";
+import b from "B";
+import d from "D";
+
+console.log(a, b, c, d)`
+);

tests/cases/fourslash/organizeImportsGroup_MultiNewlines.ts

@@ -0,0 +1,21 @@
+/// <reference path="fourslash.ts" />
+
+////import c from "C";
+////
+////
+////import d from "D";
+////import a from "A";
+////import b from "B";
+////
+////console.log(a, b, c, d)
+
+verify.organizeImports(
+`import c from "C";
+
+
+import a from "A";
+import b from "B";
+import d from "D";
+
+console.log(a, b, c, d)`
+);

tests/cases/fourslash/organizeImportsGroup_MultilineCommentInNewline.ts

@@ -0,0 +1,25 @@
+/// <reference path="fourslash.ts" />
+
+////// polyfill
+////import c from "C";
+/////*
+////* demo
+////*/
+////import d from "D";
+////import a from "A";
+////import b from "B";
+////
+////console.log(a, b, c, d)
+
+verify.organizeImports(
+`// polyfill
+import c from "C";
+/*
+* demo
+*/
+import a from "A";
+import b from "B";
+import d from "D";
+
+console.log(a, b, c, d)`
+);

tests/cases/fourslash/organizeImportsGroup_Newline.ts

@@ -0,0 +1,19 @@
+/// <reference path="fourslash.ts" />
+
+////import c from "C";
+////
+////import d from "D";
+////import a from "A"; // not count
+////import b from "B";
+////
+////console.log(a, b, c, d)
+
+verify.organizeImports(
+`import c from "C";
+
+import a from "A"; // not count
+import b from "B";
+import d from "D";
+
+console.log(a, b, c, d)`
+);