Order conditional imports based on configuration and add nested test case

Author: a7medev

Documentation/Configuration.md

@@ -296,6 +296,19 @@ too long.
 
 **default:** `false`
 
+---
+
+### `orderedImports`
+**type:** object
+
+**description:** Configuration for the `OrderedImports` rule.
+
+- `includeConditionalImports` _(boolean)_: Determines whether imports within conditional compilation blocks (`#if`, `#elseif`, `#else`) should be ordered. When `true`, imports inside conditional blocks will be sorted and organized according to the same rules as top-level imports. When `false`, imports within conditional blocks are left in their original order.
+
+**default:** `{ "includeConditionalImports" : false }`
+
+---
+
 > TODO: Add support for enabling/disabling specific syntax transformations in
 > the pipeline.
 

Documentation/RuleDocumentation.md

@@ -411,6 +411,9 @@ The order of the import groups is 1) regular imports, 2) declaration imports, 3)
 imports, and 4) @testable imports. These groups are separated by a single blank line. Blank lines in
 between the import declarations are removed.
 
+By default, imports within conditional compilation blocks (`#if`, `#elseif`, `#else`) are not ordered. This behavior can be controlled via the `orderedImports.includeConditionalImports`
+configuration option.
+
 Lint: If an import appears anywhere other than the beginning of the file it resides in,
       not lexicographically ordered, or  not in the appropriate import group, a lint error is
       raised.

Sources/SwiftFormat/API/Configuration+Default.swift

@@ -43,5 +43,6 @@ extension Configuration {
     self.multiElementCollectionTrailingCommas = true
     self.reflowMultilineStringLiterals = .never
     self.indentBlankLines = false
+    self.orderedImports = OrderedImportsConfiguration()
   }
 }

Sources/SwiftFormat/API/Configuration.swift

@@ -48,6 +48,7 @@ public struct Configuration: Codable, Equatable {
     case multiElementCollectionTrailingCommas
     case reflowMultilineStringLiterals
     case indentBlankLines
+    case orderedImports
   }
 
   /// A dictionary containing the default enabled/disabled states of rules, keyed by the rules'
@@ -301,6 +302,9 @@ public struct Configuration: Codable, Equatable {
   /// If false (the default), the whitespace in blank lines will be removed entirely.
   public var indentBlankLines: Bool
 
+  /// Configuration for the `OrderedImports` rule.
+  public var orderedImports: OrderedImportsConfiguration
+
   /// Creates a new `Configuration` by loading it from a configuration file.
   public init(contentsOf url: URL) throws {
     let data = try Data(contentsOf: url)
@@ -443,6 +447,13 @@ public struct Configuration: Codable, Equatable {
       )
       ?? defaults.indentBlankLines
 
+    self.orderedImports =
+      try container.decodeIfPresent(
+        OrderedImportsConfiguration.self,
+        forKey: .orderedImports
+      )
+      ?? defaults.orderedImports
+
     // If the `rules` key is not present at all, default it to the built-in set
     // so that the behavior is the same as if the configuration had been
     // default-initialized. To get an empty rules dictionary, one can explicitly
@@ -481,6 +492,8 @@ public struct Configuration: Codable, Equatable {
     try container.encode(noAssignmentInExpressions, forKey: .noAssignmentInExpressions)
     try container.encode(multiElementCollectionTrailingCommas, forKey: .multiElementCollectionTrailingCommas)
     try container.encode(reflowMultilineStringLiterals, forKey: .reflowMultilineStringLiterals)
+    try container.encode(indentBlankLines, forKey: .indentBlankLines)
+    try container.encode(orderedImports, forKey: .orderedImports)
     try container.encode(rules, forKey: .rules)
   }
 
@@ -546,3 +559,11 @@ public struct NoAssignmentInExpressionsConfiguration: Codable, Equatable {
 
   public init() {}
 }
+
+/// Configuration for the `OrderedImports` rule.
+public struct OrderedImportsConfiguration: Codable, Equatable {
+  /// Determines whether imports within conditional compilation blocks should be ordered.
+  public var includeConditionalImports: Bool = false
+
+  public init() {}
+}

Sources/SwiftFormat/Rules/OrderedImports.swift

@@ -127,7 +127,10 @@ public final class OrderedImports: SyntaxFormatRule {
         }
       }
 
-      if let syntaxNode = line.syntaxNode, case .ifConfigCodeBlock(let ifConfigCodeBlock) = syntaxNode {
+      if context.configuration.orderedImports.includeConditionalImports,
+        let syntaxNode = line.syntaxNode,
+        case .ifConfigCodeBlock(let ifConfigCodeBlock) = syntaxNode
+      {
         var ifConfigDecl = ifConfigCodeBlock.item.cast(IfConfigDeclSyntax.self)
 
         let newClauses = ifConfigDecl.clauses.map { clause in

Tests/SwiftFormatTests/Rules/OrderedImportsTests.swift

@@ -609,7 +609,10 @@ final class OrderedImportsTests: LintOrFormatRuleTestCase {
     )
   }
 
-  func testConditionalImports() {
+  func testConditionalImportsWhenEnabled() {
+    var configuration = Configuration.forTesting
+    configuration.orderedImports.includeConditionalImports = true
+
     assertFormatting(
       OrderedImports.self,
       input: """
@@ -650,7 +653,104 @@ final class OrderedImportsTests: LintOrFormatRuleTestCase {
         FindingSpec("2️⃣", message: "sort import statements lexicographically"),
         FindingSpec("3️⃣", message: "sort import statements lexicographically"),
         FindingSpec("4️⃣", message: "place imports at the top of the file"),
-      ]
+      ],
+      configuration: configuration
+    )
+  }
+
+  func testConditionalImportsWhenDisabled() {
+    var configuration = Configuration.forTesting
+    configuration.orderedImports.includeConditionalImports = false
+
+    assertFormatting(
+      OrderedImports.self,
+      input: """
+        import Zebras
+        1️⃣import Apples
+        #if canImport(Darwin)
+          import Foundation
+          import Darwin
+        #elseif canImport(Glibc)
+          import Glibc
+          import Foundation
+        #endif
+        2️⃣import Aardvarks
+
+        foo()
+        bar()
+        baz()
+        """,
+      expected: """
+        import Aardvarks
+        import Apples
+        import Zebras
+
+        #if canImport(Darwin)
+          import Foundation
+          import Darwin
+        #elseif canImport(Glibc)
+          import Glibc
+          import Foundation
+        #endif
+
+        foo()
+        bar()
+        baz()
+        """,
+      findings: [
+        FindingSpec("1️⃣", message: "sort import statements lexicographically"),
+        FindingSpec("2️⃣", message: "place imports at the top of the file"),
+      ],
+      configuration: configuration
+    )
+  }
+
+  func testNestedConditionalImports() {
+    var configuration = Configuration()
+    configuration.orderedImports.includeConditionalImports = true
+
+    assertFormatting(
+      OrderedImports.self,
+      input: """
+        import A
+        #if FOO
+          import D
+          #if BAR
+            import F
+            1️⃣import E
+          #else
+            import H
+            2️⃣import G
+          #endif
+          3️⃣5️⃣import C
+        #endif
+        4️⃣import B
+        """,
+      expected: """
+        import A
+        import B
+
+        #if FOO
+          import C
+          import D
+
+          #if BAR
+            import E
+            import F
+          #else
+            import G
+            import H
+          #endif
+        #endif
+        """,
+      findings: [
+        FindingSpec("1️⃣", message: "sort import statements lexicographically"),
+        FindingSpec("2️⃣", message: "sort import statements lexicographically"),
+        FindingSpec("3️⃣", message: "place imports at the top of the file"),
+        FindingSpec("4️⃣", message: "place imports at the top of the file"),
+        FindingSpec("5️⃣", message: "sort import statements lexicographically"),
+      ],
+      configuration: configuration
     )
   }