Revert "Merge changes from #2755 and add Identifier based lookup."

This reverts commit dda31f9.

Author: MAJKFL

Package.swift

@@ -143,7 +143,7 @@ let package = Package(
 
     .target(
       name: "SwiftIfConfig",
-      dependencies: ["SwiftSyntax", "SwiftDiagnostics", "SwiftOperators"],
+      dependencies: ["SwiftSyntax", "SwiftOperators"],
       exclude: ["CMakeLists.txt"]
     ),
 

Release Notes/601.md

@@ -15,10 +15,6 @@
   - Description: This method translates an error into one or more diagnostics, recognizing `DiagnosticsError` and `DiagnosticMessage` instances or providing its own `Diagnostic` as needed.
   - Pull Request: https://github.com/swiftlang/swift-syntax/pull/1816
 
-- Added a new library `SwiftIfConfig`.
-  - Description: This new library provides facilities for evaluating `#if` conditions and determining which regions of a syntax tree are active according to a given build configuration.
-  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/1816
-
 ## API Behavior Changes
 
 - `SyntaxProtocol.trimmed` detaches the node

Sources/SwiftIfConfig/ActiveSyntaxRewriter.swift

@@ -10,6 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+//
+// This file defines the SyntaxRewriter, a class that performs a standard walk
+// and tree-rebuilding pattern.
+//
+// Subclassers of this class can override the walking behavior for any syntax
+// node and transform nodes however they like.
+//
+//===----------------------------------------------------------------------===//
+
 import SwiftDiagnostics
 import SwiftSyntax
 
@@ -25,17 +34,15 @@ extension SyntaxProtocol {
   /// clauses, e.g., `#if FOO > 10`, then the condition will be
   /// considered to have failed and the clauses's elements will be
   /// removed.
-  public func removingInactive(
-    in configuration: some BuildConfiguration
-  ) -> (result: Syntax, diagnostics: [Diagnostic]) {
+  public func removingInactive(in configuration: some BuildConfiguration) -> (Syntax, [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 {
+    if visitor.numIfClausesVisited == 0 {
       return (Syntax(self), visitor.diagnostics)
     }
 
@@ -81,13 +88,12 @@ extension SyntaxProtocol {
 /// than trivia).
 class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
   let configuration: Configuration
-  var diagnostics: [Diagnostic] = []
 
   init(configuration: Configuration) {
     self.configuration = configuration
   }
 
-  private func dropInactive<List: SyntaxCollection>(
+  private func dropInactive<List: Collection & SyntaxCollection>(
     _ node: List,
     elementAsIfConfig: (List.Element) -> IfConfigDeclSyntax?
   ) -> List {
@@ -99,10 +105,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       // Find #ifs within the list.
       if let ifConfigDecl = elementAsIfConfig(element) {
         // Retrieve the active `#if` clause
-        let (activeClause, localDiagnostics) = ifConfigDecl.activeClause(in: configuration)
-
-        // Add these diagnostics.
-        diagnostics.append(contentsOf: localDiagnostics)
+        let activeClause = ifConfigDecl.activeClause(in: configuration)
 
         // If this is the first element that changed, note that we have
         // changes and add all prior elements to the list of new elements.
@@ -252,8 +255,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       return dropInactive(outerBase: base, postfixIfConfig: postfixIfConfig)
     }
 
-    assertionFailure("Unhandled postfix expression in #if elimination")
-    return postfix
+    preconditionFailure("Unhandled postfix expression in #if elimination")
   }
 
   /// Drop inactive regions from a postfix `#if` configuration, applying the
@@ -263,10 +265,7 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     postfixIfConfig: PostfixIfConfigExprSyntax
   ) -> ExprSyntax {
     // Retrieve the active `if` clause.
-    let (activeClause, localDiagnostics) = postfixIfConfig.config.activeClause(in: configuration)
-
-    // Record these diagnostics.
-    diagnostics.append(contentsOf: localDiagnostics)
+    let activeClause = postfixIfConfig.config.activeClause(in: configuration)
 
     guard case .postfixExpression(let postfixExpr) = activeClause?.elements
     else {

Sources/SwiftIfConfig/ActiveSyntaxVisitor.swift

@@ -9,7 +9,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-
 import SwiftDiagnostics
 import SwiftSyntax
 
@@ -37,34 +36,34 @@ import SwiftSyntax
 /// it would not visit either `f` or `g`.
 ///
 /// All notes visited by this visitor will have the "active" state, i.e.,
-/// `node.isActive(in: configuration)` will have evaluated to `.active`.
-/// When errors occur, they will be recorded in the array of diagnostics.
+/// `node.isActive(in: configuration)` will evaluate to `.active` or will
+/// throw. When errors occur, they will be recorded in the set of
+/// diagnostics.
 open class ActiveSyntaxVisitor<Configuration: BuildConfiguration>: SyntaxVisitor {
   /// The build configuration, which will be queried for each relevant `#if`.
   public let configuration: Configuration
 
-  /// The diagnostics accumulated during this walk of active syntax.
-  public private(set) var diagnostics: [Diagnostic] = []
+  /// The set of diagnostics accumulated during this walk of active syntax.
+  public var diagnostics: [Diagnostic] = []
 
-  /// Whether we visited any "#if" clauses.
-  var visitedAnyIfClauses: Bool = false
+  /// The number of "#if" clauses that were visited.
+  var numIfClausesVisited: Int = 0
 
   public init(viewMode: SyntaxTreeViewMode, configuration: Configuration) {
     self.configuration = configuration
     super.init(viewMode: viewMode)
   }
 
   open override func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
-    // Note: there is a clone of this code in ActiveSyntaxAnyVisitor. If you
-    // change one, please also change the other.
-    let (activeClause, localDiagnostics) = node.activeClause(in: configuration)
-    diagnostics.append(contentsOf: localDiagnostics)
+    let activeClause = node.activeClause(in: configuration) { diag in
+      self.diagnostics.append(diag)
+    }
 
-    visitedAnyIfClauses = true
+    numIfClausesVisited += 1
 
     // If there is an active clause, visit it's children.
     if let activeClause, let elements = activeClause.elements {
-      walk(elements)
+      walk(Syntax(elements))
     }
 
     // Skip everything else in the #if.
@@ -96,30 +95,32 @@ open class ActiveSyntaxVisitor<Configuration: BuildConfiguration>: SyntaxVisitor
 /// it would not visit either `f` or `g`.
 ///
 /// All notes visited by this visitor will have the "active" state, i.e.,
-/// `node.isActive(in: configuration)` will have evaluated to `.active`.
-/// When errors occur, they will be recorded in the array of diagnostics.
+/// `node.isActive(in: configuration)` will evaluate to `.active` or will
+/// throw.
+///
+/// All notes visited by this visitor will have the "active" state, i.e.,
+/// `node.isActive(in: configuration)` will evaluate to `.active` or will
+/// throw. When errors occur, they will be recorded in the set of
+/// diagnostivs.
 open class ActiveSyntaxAnyVisitor<Configuration: BuildConfiguration>: SyntaxAnyVisitor {
   /// The build configuration, which will be queried for each relevant `#if`.
   public let configuration: Configuration
 
-  /// The diagnostics accumulated during this walk of active syntax.
-  public private(set) var diagnostics: [Diagnostic] = []
+  /// The set of diagnostics accumulated during this walk of active syntax.
+  public var diagnostics: [Diagnostic] = []
 
   public init(viewMode: SyntaxTreeViewMode, configuration: Configuration) {
     self.configuration = configuration
     super.init(viewMode: viewMode)
   }
 
   open override func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
-    // Note: there is a clone of this code in ActiveSyntaxVisitor. If you
-    // change one, please also change the other.
-
     // If there is an active clause, visit it's children.
-    let (activeClause, localDiagnostics) = node.activeClause(in: configuration)
-    diagnostics.append(contentsOf: localDiagnostics)
-
+    let activeClause = node.activeClause(in: configuration) { diag in
+      self.diagnostics.append(diag)
+    }
     if let activeClause, let elements = activeClause.elements {
-      walk(elements)
+      walk(Syntax(elements))
     }
 
     // Skip everything else in the #if.

Sources/SwiftIfConfig/BuildConfiguration.swift

@@ -253,7 +253,7 @@ public protocol BuildConfiguration {
   ///
   /// The language version can be queried with the `swift` directive that checks
   /// how the supported language version compares, as described by
-  /// [SE-0212](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0212-compiler-version-directive.md). For example:
+  /// [SE-0212](https://github.com/apple/swift-evolution/blob/main/proposals/0212-compiler-version-directive.md). For example:
   ///
   /// ```swift
   /// #if swift(>=5.5)

Sources/SwiftIfConfig/CMakeLists.txt

@@ -11,7 +11,7 @@ add_swift_syntax_library(SwiftIfConfig
   ActiveSyntaxRewriter.swift
   BuildConfiguration.swift
   ConfiguredRegions.swift
-  IfConfigRegionState.swift
+  ConfiguredRegionState.swift
   IfConfigDecl+IfConfig.swift
   IfConfigError.swift
   IfConfigEvaluation.swift
@@ -25,4 +25,5 @@ add_swift_syntax_library(SwiftIfConfig
 target_link_swift_syntax_libraries(SwiftIfConfig PUBLIC
   SwiftSyntax
   SwiftDiagnostics
-  SwiftOperators)
+  SwiftOperators
+  SwiftParser)

…/SwiftIfConfig/IfConfigRegionState.swift …wiftIfConfig/ConfiguredRegionState.swiftSources/SwiftIfConfig/IfConfigRegionState.swift renamed to Sources/SwiftIfConfig/ConfiguredRegionState.swift Sources/SwiftIfConfig/IfConfigRegionState.swift renamed to Sources/SwiftIfConfig/ConfiguredRegionState.swift

@@ -9,13 +9,12 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-
 import SwiftDiagnostics
 import SwiftOperators
 import SwiftSyntax
 
 /// Describes the state of a particular region guarded by `#if` or similar.
-public enum IfConfigRegionState {
+public enum ConfiguredRegionState {
   /// The region is not part of the compiled program and is not even parsed,
   /// and therefore many contain syntax that is invalid.
   case unparsed
@@ -24,29 +23,29 @@ public enum IfConfigRegionState {
   /// The region is active and is part of the compiled program.
   case active
 
-  /// Evaluate the given `#if` condition using the given build configuration
-  /// to determine its state and identify any problems encountered along the
-  /// way.
-  public static func evaluating(
-    _ condition: some ExprSyntaxProtocol,
-    in configuration: some BuildConfiguration
-  ) -> (state: IfConfigRegionState, diagnostics: [Diagnostic]) {
+  /// Evaluate the given `#if` condition using the given build configuration, throwing an error if there is
+  /// insufficient information to make a determination.
+  public init(
+    condition: some ExprSyntaxProtocol,
+    configuration: some BuildConfiguration,
+    diagnosticHandler: ((Diagnostic) -> Void)? = nil
+  ) throws {
     // Apply operator folding for !/&&/||.
-    var foldingDiagnostics: [Diagnostic] = []
-    let foldedCondition = OperatorTable.logicalOperators.foldAll(condition) { error in
-      foldingDiagnostics.append(contentsOf: error.asDiagnostics(at: condition))
+    let foldedCondition = try OperatorTable.logicalOperators.foldAll(condition) { error in
+      diagnosticHandler?(error.asDiagnostic)
+      throw error
     }.cast(ExprSyntax.self)
 
-    let (active, versioned, evalDiagnostics) = evaluateIfConfig(
+    let (active, versioned) = try evaluateIfConfig(
       condition: foldedCondition,
-      configuration: configuration
+      configuration: configuration,
+      diagnosticHandler: diagnosticHandler
     )
 
-    let diagnostics = foldingDiagnostics + evalDiagnostics
     switch (active, versioned) {
-    case (true, _): return (.active, diagnostics)
-    case (false, false): return (.inactive, diagnostics)
-    case (false, true): return (.unparsed, diagnostics)
+    case (true, _): self = .active
+    case (false, false): self = .inactive
+    case (false, true): self = .unparsed
     }
   }
 }

Sources/SwiftIfConfig/ConfiguredRegions.swift

@@ -9,14 +9,15 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-
 import SwiftDiagnostics
 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 all
-  /// clauses to indicate regions of active / inactive / unparsed code.
+  /// 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).
   ///
   /// For example, given code like the following:
   /// #if DEBUG
@@ -36,7 +37,7 @@ extension SyntaxProtocol {
   ///   - Inactive region for the final `#else`.
   public func configuredRegions(
     in configuration: some BuildConfiguration
-  ) -> [(IfConfigClauseSyntax, IfConfigRegionState)] {
+  ) -> [(IfConfigClauseSyntax, ConfiguredRegionState)] {
     let visitor = ConfiguredRegionVisitor(configuration: configuration)
     visitor.walk(self)
     return visitor.regions
@@ -48,7 +49,7 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
   let configuration: Configuration
 
   /// The regions we've found so far.
-  var regions: [(IfConfigClauseSyntax, IfConfigRegionState)] = []
+  var regions: [(IfConfigClauseSyntax, ConfiguredRegionState)] = []
 
   /// Whether we are currently within an active region.
   var inActiveRegion = true
@@ -61,7 +62,7 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
   override func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
     // If we're in an active region, find the active clause. Otherwise,
     // there isn't one.
-    let activeClause = inActiveRegion ? node.activeClause(in: configuration).clause : nil
+    let activeClause = inActiveRegion ? node.activeClause(in: configuration) : nil
     for clause in node.clauses {
       // If this is the active clause, record it and then recurse into the
       // elements.
@@ -78,9 +79,11 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
       }
 
       // For inactive clauses, distinguish between inactive and unparsed.
-      let isVersioned = clause.isVersioned(
-        configuration: configuration
-      ).versioned
+      let isVersioned =
+        (try? clause.isVersioned(
+          configuration: configuration,
+          diagnosticHandler: nil
+        )) ?? true
 
       // If this is within an active region, or this is an unparsed region,
       // record it.