[SwiftIfConfig] Reduce the number of places that fold operators

Ensure that we only fold operators in the two entry points that
might need to do work here, rather than scattering the folding operations
around the library.

Author: DougGregor

Sources/SwiftIfConfig/ConfiguredRegions.swift

@@ -192,29 +192,21 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
       let isActive: Bool
       if let condition = clause.condition {
         if !foundActive {
-          // Fold operators so we can evaluate this #if condition.
-          let (foldedCondition, foldDiagnostics) = IfConfigClauseSyntax.foldOperators(condition)
-          diagnostics.append(contentsOf: foldDiagnostics)
-
           // In an active region, evaluate the condition to determine whether
           // this clause is active. Otherwise, this clause is inactive.
           if inActiveRegion {
             let (thisIsActive, _, evalDiagnostics) = evaluateIfConfig(
-              condition: foldedCondition,
+              condition: condition,
               configuration: configuration
             )
             diagnostics.append(contentsOf: evalDiagnostics)
 
             // Determine if there was an error that prevented us from
             // evaluating the condition. If so, we'll allow syntax errors
             // from here on out.
-            let hadError =
-              foldDiagnostics.contains { diag in
-                diag.diagMessage.severity == .error
-              }
-              || evalDiagnostics.contains { diag in
-                diag.diagMessage.severity == .error
-              }
+            let hadError = evalDiagnostics.contains { diag in
+              diag.diagMessage.severity == .error
+            }
 
             if hadError {
               isActive = false
@@ -223,14 +215,14 @@ fileprivate class ConfiguredRegionVisitor<Configuration: BuildConfiguration>: Sy
               isActive = thisIsActive
 
               // Determine whether syntax errors are allowed.
-              syntaxErrorsAllowed = foldedCondition.allowsSyntaxErrorsFolded
+              syntaxErrorsAllowed = condition.allowsSyntaxErrorsFolded
             }
           } else {
             isActive = false
 
             // Determine whether syntax errors are allowed, even though we
             // skipped evaluation of the actual condition.
-            syntaxErrorsAllowed = foldedCondition.allowsSyntaxErrorsFolded
+            syntaxErrorsAllowed = condition.allowsSyntaxErrorsFolded
           }
         } else {
           // We already found an active condition, so this is inactive.

Sources/SwiftIfConfig/IfConfigDecl+IfConfig.swift

@@ -43,13 +43,9 @@ extension IfConfigDeclSyntax {
         return (clause, diagnostics: diagnostics)
       }
 
-      // Apply operator folding for !/&&/||.
-      let (foldedCondition, foldingDiagnostics) = IfConfigClauseSyntax.foldOperators(condition)
-      diagnostics.append(contentsOf: foldingDiagnostics)
-
       // If this condition evaluates true, return this clause.
       let (isActive, _, localDiagnostics) = evaluateIfConfig(
-        condition: foldedCondition,
+        condition: condition,
         configuration: configuration
       )
       diagnostics.append(contentsOf: localDiagnostics)

Sources/SwiftIfConfig/IfConfigEvaluation.swift

@@ -34,6 +34,10 @@ func evaluateIfConfig(
 ) -> (active: Bool, syntaxErrorsAllowed: Bool, diagnostics: [Diagnostic]) {
   var extraDiagnostics: [Diagnostic] = []
 
+  // Apply operator folding for !/&&/||.
+  let (condition, foldingDiagnostics) = IfConfigClauseSyntax.foldOperators(condition)
+  extraDiagnostics.append(contentsOf: foldingDiagnostics)
+
   /// Record the error before returning the given value.
   func recordError(
     _ error: any Error,

Sources/SwiftIfConfig/IfConfigRegionState.swift

@@ -31,15 +31,11 @@ public enum IfConfigRegionState {
     _ condition: some ExprSyntaxProtocol,
     in configuration: some BuildConfiguration
   ) -> (state: IfConfigRegionState, syntaxErrorsAllowed: Bool, diagnostics: [Diagnostic]) {
-    // Apply operator folding for !/&&/||.
-    let (foldedCondition, foldingDiagnostics) = IfConfigClauseSyntax.foldOperators(condition)
-
-    let (active, syntaxErrorsAllowed, evalDiagnostics) = evaluateIfConfig(
-      condition: foldedCondition,
+    let (active, syntaxErrorsAllowed, diagnostics) = evaluateIfConfig(
+      condition: ExprSyntax(condition),
       configuration: configuration
     )
 
-    let diagnostics = foldingDiagnostics + evalDiagnostics
     switch (active, syntaxErrorsAllowed) {
     case (true, _): return (.active, syntaxErrorsAllowed, diagnostics)
     case (false, false): return (.inactive, syntaxErrorsAllowed, diagnostics)