Merge pull request #2834 from DougGregor/configured-regions-everywhere

[SwiftIfConfig] Make ConfiguredRegions and a BuildConfiguration generally interchangeable

Author: DougGregor

Sources/SwiftIfConfig/ActiveClauseEvaluator.swift

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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 SwiftSyntax
+
+/// Captures sufficient information to determine the active clause for an `#if`
+/// either by querying existing configured regions or by evaluating the
+/// clause's conditions against a build configuration.
+enum ActiveClauseEvaluator {
+  case configuredRegions(ConfiguredRegions)
+  case configuration(any BuildConfiguration)
+
+  /// Previously-known diagnostics.
+  var priorDiagnostics: [Diagnostic] {
+    switch self {
+    case .configuredRegions(let configuredRegions):
+      return configuredRegions.diagnostics
+    case .configuration:
+      return []
+    }
+  }
+
+  /// Determine which clause of an `#if` declaration is active, if any.
+  ///
+  /// If this evaluation produced any diagnostics, they will be appended to
+  /// the diagnostics parameter.
+  func activeClause(
+    for node: IfConfigDeclSyntax,
+    diagnostics: inout [Diagnostic]
+  ) -> IfConfigClauseSyntax? {
+    switch self {
+    case .configuredRegions(let configuredRegions):
+      return configuredRegions.activeClause(for: node)
+    case .configuration(let configuration):
+      let (activeClause, localDiagnostics) = node.activeClause(in: configuration)
+      diagnostics.append(contentsOf: localDiagnostics)
+      return activeClause
+    }
+  }
+}

Sources/SwiftIfConfig/ActiveSyntaxRewriter.swift

@@ -52,30 +52,69 @@ extension SyntaxProtocol {
     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
-    // does not change the tree in any way.
-    let visitor = ActiveSyntaxVisitor(viewMode: .sourceAccurate, configuration: configuration)
-    visitor.walk(self)
-
-    // If there were no active clauses to visit, we're done!
-    if !visitor.visitedAnyIfClauses {
-      return (Syntax(self), visitor.diagnostics)
-    }
-
-    // Second pass: Rewrite the syntax tree by removing the inactive clauses
+    // Rewrite the syntax tree by removing the inactive clauses
     // from each #if (along with the #ifs themselves).
     let rewriter = ActiveSyntaxRewriter(
       configuration: configuration,
       retainFeatureCheckIfConfigs: retainFeatureCheckIfConfigs
     )
     return (
       rewriter.rewrite(Syntax(self)),
-      visitor.diagnostics
+      rewriter.diagnostics
     )
   }
 }
 
+extension ConfiguredRegions {
+  /// Produce a copy of some syntax node in the configured region that removes
+  /// all syntax regions that are inactive according to the 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:
+  ///   - node: the stnrax node from which inactive regions will be removed.
+  /// - Returns: the syntax node with all inactive regions removed.
+  public func removingInactive(from node: some SyntaxProtocol) -> Syntax {
+    return removingInactive(from: node, retainFeatureCheckIfConfigs: false)
+  }
+
+  /// Produce a copy of some syntax node in the configured region that removes
+  /// all syntax regions that are inactive according to the 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:
+  ///   - node: the stnrax node from which inactive regions will be removed.
+  ///   - 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.
+  @_spi(Compiler)
+  public func removingInactive(
+    from node: some SyntaxProtocol,
+    retainFeatureCheckIfConfigs: Bool
+  ) -> Syntax {
+    // If there are no inactive regions, there's nothing to do.
+    if regions.isEmpty {
+      return Syntax(node)
+    }
+
+    // Rewrite the syntax tree by removing the inactive clauses
+    // from each #if (along with the #ifs themselves).
+    let rewriter = ActiveSyntaxRewriter(
+      configuredRegions: self,
+      retainFeatureCheckIfConfigs: retainFeatureCheckIfConfigs
+    )
+    return rewriter.rewrite(Syntax(node))
+  }
+}
+
 /// Syntax rewriter that only visits syntax nodes that are active according
 /// to a particular build configuration.
 ///
@@ -106,15 +145,22 @@ extension SyntaxProtocol {
 ///
 /// For any other target platforms, the resulting tree will be empty (other
 /// than trivia).
-class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
-  let configuration: Configuration
-  var diagnostics: [Diagnostic] = []
+class ActiveSyntaxRewriter: SyntaxRewriter {
+  let activeClauses: ActiveClauseEvaluator
+  var diagnostics: [Diagnostic]
 
   /// Whether to retain `#if` blocks containing compiler and feature checks.
   var retainFeatureCheckIfConfigs: Bool
 
-  init(configuration: Configuration, retainFeatureCheckIfConfigs: Bool) {
-    self.configuration = configuration
+  init(configuredRegions: ConfiguredRegions, retainFeatureCheckIfConfigs: Bool) {
+    self.activeClauses = .configuredRegions(configuredRegions)
+    self.diagnostics = activeClauses.priorDiagnostics
+    self.retainFeatureCheckIfConfigs = retainFeatureCheckIfConfigs
+  }
+
+  init(configuration: some BuildConfiguration, retainFeatureCheckIfConfigs: Bool) {
+    self.activeClauses = .configuration(configuration)
+    self.diagnostics = activeClauses.priorDiagnostics
     self.retainFeatureCheckIfConfigs = retainFeatureCheckIfConfigs
   }
 
@@ -124,6 +170,19 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
   ) -> List {
     var newElements: [List.Element] = []
     var anyChanged = false
+
+    // Note that an element changed at the given index.
+    func noteElementChanged(at elementIndex: List.Index) {
+      if anyChanged {
+        return
+      }
+
+      // This is the first element that changed, so note that we have
+      // changes and add all prior elements to the list of new elements.
+      anyChanged = true
+      newElements.append(contentsOf: node[..<elementIndex])
+    }
+
     for elementIndex in node.indices {
       let element = node[elementIndex]
 
@@ -132,17 +191,9 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
         (!retainFeatureCheckIfConfigs || !ifConfigDecl.containsFeatureCheck)
       {
         // Retrieve the active `#if` clause
-        let (activeClause, localDiagnostics) = ifConfigDecl.activeClause(in: configuration)
+        let activeClause = activeClauses.activeClause(for: ifConfigDecl, diagnostics: &diagnostics)
 
-        // Add these diagnostics.
-        diagnostics.append(contentsOf: localDiagnostics)
-
-        // If this is the first element that changed, note that we have
-        // changes and add all prior elements to the list of new elements.
-        if !anyChanged {
-          anyChanged = true
-          newElements.append(contentsOf: node[..<elementIndex])
-        }
+        noteElementChanged(at: elementIndex)
 
         // Extract the elements from the active clause, if there are any.
         guard let elements = activeClause?.elements else {
@@ -161,6 +212,15 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
         continue
       }
 
+      // Transform the element directly. If it changed, note the changes.
+      if let transformedElement = rewrite(Syntax(element)).as(List.Element.self),
+        transformedElement.id != element.id
+      {
+        noteElementChanged(at: elementIndex)
+        newElements.append(transformedElement)
+        continue
+      }
+
       if anyChanged {
         newElements.append(element)
       }
@@ -174,47 +234,39 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
   }
 
   override func visit(_ node: CodeBlockItemListSyntax) -> CodeBlockItemListSyntax {
-    let rewrittenNode = dropInactive(node) { element in
+    return dropInactive(node) { element in
       guard case .decl(let declElement) = element.item else {
         return nil
       }
 
       return declElement.as(IfConfigDeclSyntax.self)
     }
-
-    return super.visit(rewrittenNode)
   }
 
   override func visit(_ node: MemberBlockItemListSyntax) -> MemberBlockItemListSyntax {
-    let rewrittenNode = dropInactive(node) { element in
+    return dropInactive(node) { element in
       return element.decl.as(IfConfigDeclSyntax.self)
     }
-
-    return super.visit(rewrittenNode)
   }
 
   override func visit(_ node: SwitchCaseListSyntax) -> SwitchCaseListSyntax {
-    let rewrittenNode = dropInactive(node) { element in
+    return dropInactive(node) { element in
       if case .ifConfigDecl(let ifConfigDecl) = element {
         return ifConfigDecl
       }
 
       return nil
     }
-
-    return super.visit(rewrittenNode)
   }
 
   override func visit(_ node: AttributeListSyntax) -> AttributeListSyntax {
-    let rewrittenNode = dropInactive(node) { element in
+    return dropInactive(node) { element in
       if case .ifConfigDecl(let ifConfigDecl) = element {
         return ifConfigDecl
       }
 
       return nil
     }
-
-    return super.visit(rewrittenNode)
   }
 
   /// Apply the given base to the postfix expression.
@@ -234,7 +286,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
         return nil
       }
 
-      let newExpr = applyBaseToPostfixExpression(base: base, postfix: node[keyPath: keyPath])
+      let newExpr = applyBaseToPostfixExpression(base: base, postfix: visit(node[keyPath: keyPath]))
       return ExprSyntax(node.with(keyPath, newExpr))
     }
 
@@ -243,7 +295,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       guard let memberBase = memberAccess.base else {
         // If this member access has no base, this is the base we are
         // replacing, terminating the recursion. Do so now.
-        return ExprSyntax(memberAccess.with(\.base, base))
+        return ExprSyntax(memberAccess.with(\.base, visit(base)))
       }
 
       let newBase = applyBaseToPostfixExpression(base: base, postfix: memberBase)
@@ -302,10 +354,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     }
 
     // Retrieve the active `if` clause.
-    let (activeClause, localDiagnostics) = postfixIfConfig.config.activeClause(in: configuration)
-
-    // Record these diagnostics.
-    diagnostics.append(contentsOf: localDiagnostics)
+    let activeClause = activeClauses.activeClause(for: postfixIfConfig.config, diagnostics: &diagnostics)
 
     guard case .postfixExpression(let postfixExpr) = activeClause?.elements
     else {
@@ -315,7 +364,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       // only have both in an ill-formed syntax tree that was manually
       // created.
       if let base = postfixIfConfig.base ?? outerBase {
-        return base
+        return visit(base)
       }
 
       // If there was no base, we're in an erroneous syntax tree that would
@@ -330,20 +379,15 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
 
     // If there is no base, return the postfix expression.
     guard let base = postfixIfConfig.base ?? outerBase else {
-      return postfixExpr
+      return visit(postfixExpr)
     }
 
     // Apply the base to the postfix expression.
     return applyBaseToPostfixExpression(base: base, postfix: postfixExpr)
   }
 
   override func visit(_ node: PostfixIfConfigExprSyntax) -> ExprSyntax {
-    let rewrittenNode = dropInactive(outerBase: nil, postfixIfConfig: node)
-    if rewrittenNode == ExprSyntax(node) {
-      return rewrittenNode
-    }
-
-    return visit(rewrittenNode)
+    return dropInactive(outerBase: nil, postfixIfConfig: node)
   }
 }