Address more comments

Author: DougGregor

Sources/SwiftIfConfig/ConfiguredRegions.swift

@@ -15,10 +15,8 @@ import SwiftSyntax
 
 extension SyntaxProtocol {
   /// Find all of the #if/#elseif/#else clauses within the given syntax node,
-  /// indicating their active state. This operation will recurse into active
-  /// clauses to represent the flattened nested structure, while nonactive
-  /// clauses need no recursion (because there is no relevant structure in
-  /// them).
+  /// indicating their active state. This operation will recurse into all
+  /// clauses to indicate regions of active / inactive / unparsed code.
   ///
   /// For example, given code like the following:
   /// #if DEBUG

Sources/SwiftIfConfig/IfConfigDecl+IfConfig.swift

@@ -26,7 +26,7 @@ extension IfConfigDeclSyntax {
   /// ```
   ///
   /// If the `A` configuration option was passed on the command line (e.g. via `-DA`), the first clause
-  /// (containing `func f()`) would be returned. If not, and if the `B`configuration was passed on the
+  /// (containing `func f()`) would be returned. If not, and if the `B` configuration was passed on the
   /// command line, the second clause (containing `func g()`) would be returned. If neither was
   /// passed, this function will return `nil` to indicate that none of the regions are active.
   ///

Sources/SwiftIfConfig/SyntaxProtocol+IfConfig.swift

@@ -40,7 +40,7 @@ extension SyntaxProtocol {
     while let parent = currentNode.parent {
       // If the parent is an `#if` configuration, check whether our current
       // clause is active. If not, we're in an inactive region. We also
-      // need to determine whether
+      // need to determine whether an inactive region should be parsed or not.
       if let ifConfigClause = currentNode.as(IfConfigClauseSyntax.self),
         let ifConfigDecl = ifConfigClause.parent?.parent?.as(IfConfigDeclSyntax.self)
       {
@@ -73,8 +73,9 @@ extension SyntaxProtocol {
   /// Determine whether the given syntax node is active given a set of
   /// configured regions as produced by `configuredRegions(in:)`.
   ///
-  /// This is
-  /// an approximation
+  /// If you are querying whether many syntax nodes in a particular file are
+  /// active, consider calling `configuredRegions(in:)` once and using
+  /// this function. For occasional queries, use `isActive(in:)`.
   public func isActive(
     inConfiguredRegions regions: [(IfConfigClauseSyntax, IfConfigRegionState)]
   ) -> IfConfigRegionState {

Sources/SwiftSyntaxMacrosGenericTestSupport/Assertions.swift

@@ -365,6 +365,7 @@ public enum DiagnosticAssertionContext {
   }
 }
 
+@_spi(Testing)
 public func assertDiagnostic(
   _ diag: Diagnostic,
   in expansionContext: DiagnosticAssertionContext,

Tests/SwiftIfConfigTest/ActiveRegionTests.swift

@@ -16,6 +16,8 @@ import SwiftParser
 import SwiftSyntax
 import SwiftSyntaxMacrosGenericTestSupport
 import XCTest
+import _SwiftSyntaxGenericTestSupport
+import _SwiftSyntaxTestSupport
 
 public class ActiveRegionTests: XCTestCase {
   let linuxBuildConfig = TestingBuildConfiguration(
@@ -99,3 +101,45 @@ public class ActiveRegionTests: XCTestCase {
     )
   }
 }
+
+/// Assert that the various marked positions in the source code have the
+/// expected active states.
+func assertActiveCode(
+  _ markedSource: String,
+  configuration: some BuildConfiguration = TestingBuildConfiguration(),
+  states: [String: IfConfigRegionState],
+  file: StaticString = #filePath,
+  line: UInt = #line
+) throws {
+  // Pull out the markers that we'll use to dig out nodes to query.
+  let (markerLocations, source) = extractMarkers(markedSource)
+
+  var parser = Parser(source)
+  let tree = SourceFileSyntax.parse(from: &parser)
+
+  let configuredRegions = tree.configuredRegions(in: configuration)
+
+  for (marker, location) in markerLocations {
+    guard let expectedState = states[marker] else {
+      XCTFail("Missing marker \(marker) in expected states", file: file, line: line)
+      continue
+    }
+
+    guard let token = tree.token(at: AbsolutePosition(utf8Offset: location)) else {
+      XCTFail("Unable to find token at location \(location)", file: file, line: line)
+      continue
+    }
+
+    let (actualState, _) = token.isActive(in: configuration)
+    XCTAssertEqual(actualState, expectedState, "isActive(in:) at marker \(marker)", file: file, line: line)
+
+    let actualViaRegions = token.isActive(inConfiguredRegions: configuredRegions)
+    XCTAssertEqual(
+      actualViaRegions,
+      expectedState,
+      "isActive(inConfiguredRegions:) at marker \(marker)",
+      file: file,
+      line: line
+    )
+  }
+}

Tests/SwiftIfConfigTest/Assertions.swift

@@ -10,12 +10,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SwiftDiagnostics
 import SwiftIfConfig
 import SwiftParser
 import SwiftSyntax
-import SwiftSyntaxMacrosGenericTestSupport
+@_spi(XCTestFailureLocation) @_spi(Testing) import SwiftSyntaxMacrosGenericTestSupport
 import XCTest
 import _SwiftSyntaxTestSupport
+import _SwiftSyntaxGenericTestSupport
 
 public class EvaluateTests: XCTestCase {
   func testLiterals() throws {
@@ -229,3 +231,43 @@ public class EvaluateTests: XCTestCase {
     )
   }
 }
+
+/// Assert the results of evaluating the condition within an `#if` against the
+/// given build configuration.
+func assertIfConfig(
+  _ condition: ExprSyntax,
+  _ expectedState: IfConfigRegionState,
+  configuration: some BuildConfiguration = TestingBuildConfiguration(),
+  diagnostics expectedDiagnostics: [DiagnosticSpec] = [],
+  file: StaticString = #filePath,
+  line: UInt = #line
+) {
+  // Evaluate the condition to check the state.
+  let actualDiagnostics: [Diagnostic]
+  let actualState: IfConfigRegionState
+    (actualState, actualDiagnostics) = IfConfigRegionState.evaluating (condition, in: configuration)
+  XCTAssertEqual(actualState, expectedState, file: file, line: line)
+
+  // Check the diagnostics.
+  if actualDiagnostics.count != expectedDiagnostics.count {
+    XCTFail(
+      """
+      Expected \(expectedDiagnostics.count) diagnostics, but got \(actualDiagnostics.count):
+      \(actualDiagnostics.map(\.debugDescription).joined(separator: "\n"))
+      """,
+      file: file,
+      line: line
+    )
+  } else {
+    for (actualDiag, expectedDiag) in zip(actualDiagnostics, expectedDiagnostics) {
+      assertDiagnostic(
+        actualDiag,
+        in: .tree(condition),
+        expected: expectedDiag,
+        failureHandler: {
+          XCTFail($0.message, file: $0.location.staticFilePath, line: $0.location.unsignedLine)
+        }
+      )
+    }
+  }
+}

Tests/SwiftIfConfigTest/EvaluateTests.swift

@@ -14,8 +14,10 @@ import SwiftDiagnostics
 import SwiftIfConfig
 import SwiftParser
 import SwiftSyntax
-import SwiftSyntaxMacrosGenericTestSupport
+@_spi(XCTestFailureLocation) @_spi(Testing) import SwiftSyntaxMacrosGenericTestSupport
 import XCTest
+import _SwiftSyntaxTestSupport
+import _SwiftSyntaxGenericTestSupport
 
 /// Visitor that ensures that all of the nodes we visit are active.
 ///
@@ -252,3 +254,50 @@ public class VisitorTests: XCTestCase {
     )
   }
 }
+
+/// Assert that applying the given build configuration to the source code
+/// returns the expected source and diagnostics.
+func assertRemoveInactive(
+  _ source: String,
+  configuration: some BuildConfiguration,
+  diagnostics expectedDiagnostics: [DiagnosticSpec] = [],
+  expectedSource: String,
+  file: StaticString = #filePath,
+  line: UInt = #line
+) {
+  var parser = Parser(source)
+  let tree = SourceFileSyntax.parse(from: &parser)
+
+  let (treeWithoutInactive, actualDiagnostics) = tree.removingInactive(in: configuration)
+
+  // Check the resulting tree.
+  assertStringsEqualWithDiff(
+    treeWithoutInactive.description,
+    expectedSource,
+    file: file,
+    line: line
+  )
+
+  // Check the diagnostics.
+  if actualDiagnostics.count != expectedDiagnostics.count {
+    XCTFail(
+      """
+      Expected \(expectedDiagnostics.count) diagnostics, but got \(actualDiagnostics.count):
+      \(actualDiagnostics.map(\.debugDescription).joined(separator: "\n"))
+      """,
+      file: file,
+      line: line
+    )
+  } else {
+    for (actualDiag, expectedDiag) in zip(actualDiagnostics, expectedDiagnostics) {
+      assertDiagnostic(
+        actualDiag,
+        in: .tree(tree),
+        expected: expectedDiag,
+        failureHandler: {
+          XCTFail($0.message, file: $0.location.staticFilePath, line: $0.location.unsignedLine)
+        }
+      )
+    }
+  }
+}