Implementation of the compiler's "extract inlinable text"

Sources/SwiftIfConfig/ActiveSyntaxRewriter.swift

@@ -18,15 +18,39 @@ extension SyntaxProtocol {
   /// are inactive according to the given build configuration, leaving only
   /// the code that is active within that build configuration.
   ///
-  /// Returns the syntax node with all inactive regions removed, along with an
-  /// array containing any diagnostics produced along the way.
-  ///
   /// If there are errors in the conditions of any configuration
   /// clauses, e.g., `#if FOO > 10`, then the condition will be
   /// considered to have failed and the clauses's elements will be
   /// removed.
+  /// - Parameters:
+  ///   - configuration: the configuration to apply.
+  /// - Returns: the syntax node with all inactive regions removed, along with
+  ///   an array containing any diagnostics produced along the way.
   public func removingInactive(
     in configuration: some BuildConfiguration
+  ) -> (result: Syntax, diagnostics: [Diagnostic]) {
+    return removingInactive(in: configuration, retainFeatureCheckIfConfigs: false)
+  }
+
+  /// Produce a copy of this syntax node that removes all syntax regions that
+  /// are inactive according to the given build configuration, leaving only
+  /// the code that is active within that build configuration.
+  ///
+  /// If there are errors in the conditions of any configuration
+  /// clauses, e.g., `#if FOO > 10`, then the condition will be
+  /// considered to have failed and the clauses's elements will be
+  /// removed.
+  /// - Parameters:
+  ///   - configuration: the configuration to apply.
+  ///   - retainFeatureCheckIfConfigs: whether to retain `#if` blocks involving
+  ///     compiler version checks (e.g., `compiler(>=6.0)`) and `$`-based
+  ///     feature checks.
+  /// - Returns: the syntax node with all inactive regions removed, along with
+  ///   an array containing any diagnostics produced along the way.
+  @_spi(Compiler)
+  public func removingInactive(
+    in configuration: some BuildConfiguration,
+    retainFeatureCheckIfConfigs: Bool
   ) -> (result: Syntax, diagnostics: [Diagnostic]) {
     // First pass: Find all of the active clauses for the #ifs we need to
     // visit, along with any diagnostics produced along the way. This process
@@ -41,7 +65,10 @@ extension SyntaxProtocol {
 
     // Second pass: Rewrite the syntax tree by removing the inactive clauses
     // from each #if (along with the #ifs themselves).
-    let rewriter = ActiveSyntaxRewriter(configuration: configuration)
+    let rewriter = ActiveSyntaxRewriter(
+      configuration: configuration,
+      retainFeatureCheckIfConfigs: retainFeatureCheckIfConfigs
+    )
     return (
       rewriter.rewrite(Syntax(self)),
       visitor.diagnostics
@@ -83,8 +110,12 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
   let configuration: Configuration
   var diagnostics: [Diagnostic] = []
 
-  init(configuration: Configuration) {
+  /// Whether to retain `#if` blocks containing compiler and feature checks.
+  var retainFeatureCheckIfConfigs: Bool
+
+  init(configuration: Configuration, retainFeatureCheckIfConfigs: Bool) {
     self.configuration = configuration
+    self.retainFeatureCheckIfConfigs = retainFeatureCheckIfConfigs
   }
 
   private func dropInactive<List: SyntaxCollection>(
@@ -97,7 +128,9 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       let element = node[elementIndex]
 
       // Find #ifs within the list.
-      if let ifConfigDecl = elementAsIfConfig(element) {
+      if let ifConfigDecl = elementAsIfConfig(element),
+        (!retainFeatureCheckIfConfigs || !ifConfigDecl.containsFeatureCheck)
+      {
         // Retrieve the active `#if` clause
         let (activeClause, localDiagnostics) = ifConfigDecl.activeClause(in: configuration)
 
@@ -262,6 +295,12 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     outerBase: ExprSyntax?,
     postfixIfConfig: PostfixIfConfigExprSyntax
   ) -> ExprSyntax {
+    // If we're supposed to retain #if configs that are feature checks, and
+    // this configuration has one, do so.
+    if retainFeatureCheckIfConfigs && postfixIfConfig.config.containsFeatureCheck {
+      return ExprSyntax(postfixIfConfig)
+    }
+
     // Retrieve the active `if` clause.
     let (activeClause, localDiagnostics) = postfixIfConfig.config.activeClause(in: configuration)
 
@@ -307,3 +346,104 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     return visit(rewrittenNode)
   }
 }
+
+/// Helper class to find a feature or compiler check.
+fileprivate class FindFeatureCheckVisitor: SyntaxVisitor {
+  var foundFeatureCheck = false
+
+  override func visit(_ node: DeclReferenceExprSyntax) -> SyntaxVisitorContinueKind {
+    // Checks that start with $ are feature checks that should be retained.
+    if let identifier = node.simpleIdentifier,
+      let initialChar = identifier.name.first,
+      initialChar == "$"
+    {
+      foundFeatureCheck = true
+      return .skipChildren
+    }
+
+    return .visitChildren
+  }
+
+  override func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
+    if let calleeDeclRef = node.calledExpression.as(DeclReferenceExprSyntax.self),
+      let calleeName = calleeDeclRef.simpleIdentifier?.name,
+      (calleeName == "compiler" || calleeName == "_compiler_version")
+    {
+      foundFeatureCheck = true
+    }
+
+    return .skipChildren
+  }
+}
+
+extension ExprSyntaxProtocol {
+  /// Whether any of the nodes in this expression involve compiler or feature
+  /// checks.
+  fileprivate var containsFeatureCheck: Bool {
+    let visitor = FindFeatureCheckVisitor(viewMode: .fixedUp)
+    visitor.walk(self)
+    return visitor.foundFeatureCheck
+  }
+}
+
+extension IfConfigDeclSyntax {
+  /// Whether any of the clauses in this #if contain a feature check.
+  var containsFeatureCheck: Bool {
+    return clauses.contains { clause in
+      if let condition = clause.condition {
+        return condition.containsFeatureCheck
+      } else {
+        return false
+      }
+    }
+  }
+}
+
+extension SyntaxProtocol {
+  // Produce the source code for this syntax node with all of the comments
+  // and #sourceLocations removed. Each comment will be replaced with either
+  // a newline or a space, depending on whether the comment involved a newline.
+  @_spi(Compiler)
+  public var descriptionWithoutCommentsAndSourceLocations: String {
+    var result = ""
+    var skipUntilRParen = false
+    for token in tokens(viewMode: .sourceAccurate) {
+      // Skip #sourceLocation(...).
+      if token.tokenKind == .poundSourceLocation {
+        skipUntilRParen = true
+        continue
+      }
+
+      if skipUntilRParen {
+        if token.tokenKind == .rightParen {
+          skipUntilRParen = false
+        }
+        continue
+      }
+
+      token.leadingTrivia.writeWithoutComments(to: &result)
+      token.text.write(to: &result)
+      token.trailingTrivia.writeWithoutComments(to: &result)
+    }
+    return result
+  }
+}
+
+extension Trivia {
+  fileprivate func writeWithoutComments(to stream: inout some TextOutputStream) {
+    for piece in pieces {
+      switch piece {
+      case .backslashes, .carriageReturnLineFeeds, .carriageReturns, .formfeeds, .newlines, .pounds, .spaces, .tabs,
+        .unexpectedText, .verticalTabs:
+        piece.write(to: &stream)
+
+      case .blockComment(let text), .docBlockComment(let text), .docLineComment(let text), .lineComment(let text):
+        if text.contains(where: \.isNewline) {
+          stream.write("\n")
+        } else {
+          stream.write(" ")
+        }
+      }
+    }
+  }
+}

Sources/SwiftIfConfig/BuildConfiguration.swift

@@ -9,6 +9,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+
 import SwiftSyntax
 
 /// Describes the ordering of a sequence of bytes that make up a word of

Sources/SwiftIfConfig/ConfiguredRegions.swift

@@ -37,7 +37,7 @@ import SwiftSyntax
 ///   - Unparsed region for the `#elseif compiler(>= 12.0)`.
 ///   - Inactive region for the final `#else`.
 public struct ConfiguredRegions {
-  let regions: [Element]
+  let regions: [(ifClause: IfConfigClauseSyntax, state: IfConfigRegionState)]
 
   /// The set of diagnostics produced when evaluating the configured regions.
   public let diagnostics: [Diagnostic]
@@ -59,13 +59,13 @@ public struct ConfiguredRegions {
       let middle = currentSlice.startIndex + currentSlice.count / 2
 
       // If the node is prior to the start of the middle, take the left-hand side.
-      if node.position < currentSlice[middle].0.regionStart {
+      if node.position < currentSlice[middle].ifClause.regionStart {
         currentSlice = currentSlice[..<middle]
         continue
       }
 
       // If the node is after the end of the middle, take the right-hand side.
-      if node.position > currentSlice[middle].0.endPosition {
+      if node.position > currentSlice[middle].ifClause.endPosition {
         currentSlice = currentSlice[(middle + 1)...]
         continue
       }
@@ -77,13 +77,13 @@ public struct ConfiguredRegions {
     // Find the last region in which this node lands. If there is no such
     // region, this is active.
     return currentSlice.last { region in
-      node.position >= region.0.regionStart && node.position <= region.0.endPosition
-    }?.1 ?? .active
+      (region.ifClause.regionStart...region.ifClause.endPosition).contains(node.position)
+    }?.state ?? .active
   }
 }
 
 extension ConfiguredRegions: RandomAccessCollection {
-  public typealias Element = (IfConfigClauseSyntax, IfConfigRegionState)
+  public typealias Element = (ifClause: IfConfigClauseSyntax, state: IfConfigRegionState)
   public var startIndex: Int { regions.startIndex }
   public var endIndex: Int { regions.endIndex }
 
@@ -99,7 +99,7 @@ extension ConfiguredRegions: CustomDebugStringConvertible {
       return "[]"
     }
 
-    let root = firstRegion.0.root
+    let root = firstRegion.ifClause.root
     let converter = SourceLocationConverter(fileName: "", tree: root)
     let regionDescriptions = regions.map { (ifClause, state) in
       let startPosition = converter.location(for: ifClause.position)
@@ -198,7 +198,6 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
 
           // In an active region, evaluate the condition to determine whether
           // this clause is active. Otherwise, this clause is inactive.
-          // inactive.
           if inActiveRegion {
             let (thisIsActive, _, evalDiagnostics) = evaluateIfConfig(
               condition: foldedCondition,

Sources/SwiftIfConfig/SwiftIfConfig.docc/SwiftIfConfig.md

@@ -29,8 +29,4 @@ The `SwiftIfConfig` library provides utilities to determine which syntax nodes a
 * <doc:ActiveSyntaxVisitor> and <doc:ActiveSyntaxAnyVisitor> are visitor types that only visit the syntax nodes that are included ("active") for a given build configuration, implicitly skipping any nodes within inactive `#if` clauses.
 * `SyntaxProtocol.removingInactive(in:)` produces a syntax node that removes all inactive regions (and their corresponding `IfConfigDeclSyntax` nodes) from the given syntax tree, returning a new tree that is free of `#if` conditions.
 * `IfConfigDeclSyntax.activeClause(in:)` determines which of the clauses of an `#if` is active for the given build configuration, returning the active clause.
-* `SyntaxProtocol.isActive(in:)` determines whether the given syntax node is active for the given build configuration. The result is one of "active"
-    (the node is included in the program), "inactive" (the node is not included
-    in the program), or "unparsed" (the node is not included in the program and
-    is also allowed to have syntax errors).
-* `SyntaxProtocol.configuredRegions(in:)` produces an array describing the various regions in which a configuration has an effect, indicating active, inactive, and unparsed regions in the source tree. The array can be used as an input to `SyntaxProtocol.isActive(inConfiguredRegions:)` to determine whether a given syntax node is active.
+* `SyntaxProtocol.configuredRegions(in:)` produces a `ConfiguredRegions` value that can be used to efficiently test whether a given syntax node is in an active, inactive, or unparsed region (via `isActive`).

Sources/SwiftIfConfig/SyntaxProtocol+IfConfig.swift

@@ -47,17 +47,4 @@ extension SyntaxProtocol {
     let configuredRegions = root.configuredRegions(in: configuration)
     return (configuredRegions.isActive(self), configuredRegions.diagnostics)
   }
-
-  /// Determine whether the given syntax node is active given a set of
-  /// configured regions as produced by `configuredRegions(in:)`.
-  ///
-  /// 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:)`.
-  @available(*, deprecated, message: "Please use ConfiguredRegions.isActive(_:)")
-  public func isActive(
-    inConfiguredRegions regions: ConfiguredRegions
-  ) -> IfConfigRegionState {
-    regions.isActive(self)
-  }
 }