Rework isActive(in: configuration) to distinguish inactive vs. unparsed

Update the interface of this function to return an `IfConfigState` rather
than just a `Bool`. Then, check the enclosing versioned conditions to
distinguish between inactive vs. unparsed. Finally, add a marker-based
assertion function that makes it easy to test the active state of any
location in the source code. Use the new test to flush out an obvious
bug in my original implementation of `isActive(in: configuration)`.

Author: DougGregor

Sources/SwiftIfConfig/IfConfigEvaluation.swift

@@ -715,25 +715,55 @@ extension SyntaxProtocol {
   ///   #endif
   /// #endif
   ///
-  /// a call to `isActive` on the syntax node for the function `g` would return `true` when the
+  /// a call to `isActive` on the syntax node for the function `g` would return `active` when the
   /// configuration options `DEBUG` and `B` are provided, but `A` is not.
-  public func isActive(in configuration: some BuildConfiguration) throws -> Bool {
+  public func isActive(
+    in configuration: some BuildConfiguration,
+    diagnosticHandler: ((Diagnostic) -> Void)? = nil
+  ) throws -> IfConfigState {
     var currentNode: Syntax = Syntax(self)
+    var currentState: IfConfigState = .active
+
     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.
+      // clause is active. If not, we're in an inactive region. We also
+      // need to determine whether
       if let ifConfigClause = currentNode.as(IfConfigClauseSyntax.self),
-        let ifConfigDecl = ifConfigClause.parent?.as(IfConfigDeclSyntax.self)
+        let ifConfigDecl = ifConfigClause.parent?.parent?.as(IfConfigDeclSyntax.self)
       {
-        if try ifConfigDecl.activeClause(in: configuration) != ifConfigClause {
-          return false
+        let activeClause = try ifConfigDecl.activeClause(
+          in: configuration,
+          diagnosticHandler: diagnosticHandler
+        )
+
+        if activeClause != ifConfigClause {
+          // This was not the active clause, so we know that we're in an
+          // inactive block. However, depending on the condition of this
+          // clause and any enclosing clauses, it might be an unparsed block.
+
+          // Check this condition.
+          if let condition = ifConfigClause.condition {
+            // Evaluate this condition against the build configuration.
+            let (_, versioned) = try evaluateIfConfig(
+              condition: condition,
+              configuration: configuration,
+              diagnosticHandler: diagnosticHandler
+            )
+
+            // If the condition is versioned, this is an unparsed region.
+            // We already know that it is inactive, or we wouldn't be here.
+            if versioned {
+              return .unparsed
+            }
+          }
+
+          currentState = .inactive
         }
       }
 
       currentNode = parent
     }
 
-    // No more enclosing nodes; this code is active.
-    return true
+    return currentState
   }
 }

Sources/SwiftIfConfig/IfConfigVisitor.swift

@@ -75,7 +75,7 @@ open class ActiveSyntaxVisitor<Configuration: BuildConfiguration>: SyntaxVisitor
         walk(Syntax(elements))
       }
 
-      // Skip everything else in the
+      // Skip everything else in the #if.
       return .skipChildren
     } catch {
       return reportEvaluationError(at: node, error: error)

Tests/SwiftIfConfigTest/ActiveRegionTests.swift

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+import SwiftDiagnostics
+import SwiftIfConfig
+import SwiftParser
+import SwiftSyntax
+import SwiftSyntaxMacrosGenericTestSupport
+import XCTest
+
+public class ActiveRegionTests: XCTestCase {
+  let linuxBuildConfig = TestingBuildConfiguration(
+    customConditions: ["DEBUG", "ASSERTS"],
+    features: ["ParameterPacks"],
+    attributes: ["available"]
+  )
+
+  func testActiveRegions() throws {
+    try assertActiveCode(
+      """
+      #if DEBUG
+      0️⃣func f()
+      #elseif ASSERTS
+      1️⃣func g()
+
+      #if compiler(>=8.0)
+      2️⃣func h()
+      #else
+      3️⃣var i
+      #endif
+      #endif
+      """,
+      configuration: linuxBuildConfig,
+      states: [
+        "0️⃣": .active,
+        "1️⃣": .inactive,
+        "2️⃣": .unparsed,
+        "3️⃣": .inactive,
+      ]
+    )
+  }
+}

Tests/SwiftIfConfigTest/Assertions.swift

@@ -61,7 +61,37 @@ func assertIfConfig(
       )
     }
   }
+}
 
+/// 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: IfConfigState],
+  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)
+
+  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 = try token.isActive(in: configuration)
+    XCTAssertEqual(actualState, expectedState, "at marker \(marker)", file: file, line: line)
+  }
 }
 
 /// Assert that applying the given build configuration to the source code

Tests/SwiftIfConfigTest/VisitorTests.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -25,9 +25,9 @@ class AllActiveVisitor: ActiveSyntaxAnyVisitor<TestingBuildConfiguration> {
     super.init(viewMode: .sourceAccurate, configuration: configuration)
   }
   open override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
-    var active: Bool = false
+    var active: IfConfigState = .inactive
     XCTAssertNoThrow(try active = node.isActive(in: configuration))
-    XCTAssertTrue(active)
+    XCTAssertEqual(active, .active)
     return .visitChildren
   }
 }