fix: fix dangerous cases

Author: hugop95

rules/sort-modules.ts

@@ -195,27 +195,16 @@ function analyzeModule({
   for (let node of module.body) {
     switch (node.type) {
       case AST_NODE_TYPES.TSNamespaceExportDeclaration:
-      case AST_NODE_TYPES.TSImportEqualsDeclaration:
       case AST_NODE_TYPES.ExportAllDeclaration:
-      case AST_NODE_TYPES.TSExportAssignment:
       case AST_NODE_TYPES.ImportDeclaration:
       case AST_NODE_TYPES.DebuggerStatement:
       case AST_NODE_TYPES.ContinueStatement:
-      case AST_NODE_TYPES.DoWhileStatement:
-      case AST_NODE_TYPES.LabeledStatement:
+      /* v8 ignore next 4 -- @preserve These statements cannot appear at module/namespace level in valid code. */
+      // eslint-disable-next-line no-fallthrough
       case AST_NODE_TYPES.ReturnStatement:
-      case AST_NODE_TYPES.SwitchStatement:
       case AST_NODE_TYPES.EmptyStatement:
       case AST_NODE_TYPES.BreakStatement:
-      case AST_NODE_TYPES.WhileStatement:
-      case AST_NODE_TYPES.ForInStatement:
-      case AST_NODE_TYPES.ForOfStatement:
-      case AST_NODE_TYPES.ThrowStatement:
-      case AST_NODE_TYPES.BlockStatement:
       case AST_NODE_TYPES.WithStatement:
-      case AST_NODE_TYPES.ForStatement:
-      case AST_NODE_TYPES.TryStatement:
-      case AST_NODE_TYPES.IfStatement:
         continue
       case AST_NODE_TYPES.ExportDefaultDeclaration:
       case AST_NODE_TYPES.ExportNamedDeclaration:
@@ -224,8 +213,21 @@ function analyzeModule({
       case AST_NODE_TYPES.FunctionDeclaration:
       case AST_NODE_TYPES.TSModuleDeclaration:
         break
+      case AST_NODE_TYPES.TSImportEqualsDeclaration:
       case AST_NODE_TYPES.VariableDeclaration:
       case AST_NODE_TYPES.ExpressionStatement:
+      case AST_NODE_TYPES.TSExportAssignment:
+      case AST_NODE_TYPES.DoWhileStatement:
+      case AST_NODE_TYPES.LabeledStatement:
+      case AST_NODE_TYPES.SwitchStatement:
+      case AST_NODE_TYPES.WhileStatement:
+      case AST_NODE_TYPES.ForInStatement:
+      case AST_NODE_TYPES.ForOfStatement:
+      case AST_NODE_TYPES.ThrowStatement:
+      case AST_NODE_TYPES.BlockStatement:
+      case AST_NODE_TYPES.ForStatement:
+      case AST_NODE_TYPES.TryStatement:
+      case AST_NODE_TYPES.IfStatement:
         sortingNodeGroupsWithoutOverloadSignature.push([])
         continue
       case AST_NODE_TYPES.TSDeclareFunction:

test/rules/sort-modules.test.ts

@@ -285,6 +285,204 @@ describe('sort-modules', () => {
       })
     })
 
+    it('creates partitions at if statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          if (B.b === 'b') {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at while statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          while (B.b === 'b') {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at for-in loops', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          for (const key in B) {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at try/catch statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          try { B.b } catch {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at for loops', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          for (let i = 0; i < Object.keys(B).length; i++) {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at for-of loops', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          for (const value of Object.values(B)) {}
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at do-while loops', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          do { void B.b } while (false)
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at switch statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          switch (B.b) { case 'b': break }
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at throw statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          throw new Error(B.b)
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at block statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          { const x = B.b }
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at labeled statements', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          label: { const x = B.b }
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at TypeScript import-equals declarations', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          import A = B
+          enum C { c = 'c' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('creates partitions at export assignments', async () => {
+      await valid({
+        code: dedent`
+          enum B { b = 'b' }
+          export = B
+          enum A { a = 'a' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('sorts across empty statements', async () => {
+      await valid({
+        code: dedent`
+          enum A { a = 'a' }
+          ;
+          enum B { b = 'b' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('sorts across debugger statements', async () => {
+      await valid({
+        code: dedent`
+          enum A { a = 'a' }
+          debugger
+          enum B { b = 'b' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('sorts across import declarations', async () => {
+      await valid({
+        code: dedent`
+          enum A { a = 'a' }
+          import 'x'
+          enum B { b = 'b' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('sorts across export-all declarations', async () => {
+      await valid({
+        code: dedent`
+          enum A { a = 'a' }
+          export * from 'x'
+          enum B { b = 'b' }
+        `,
+        options: [options],
+      })
+    })
+
+    it('sorts across namespace export declarations', async () => {
+      await valid({
+        code: dedent`
+          enum A { a = 'a' }
+          export as namespace Foo
+          enum B { b = 'b' }
+        `,
+        options: [options],
+      })
+    })
+
     it('accepts complex predefined group configurations', async () => {
       await valid({
         options: [