Add support for evaluating swift and compiler conditionals

These were introduced by SE-0212.

Author: DougGregor

Sources/SwiftIfConfig/BuildConfiguration.swift

@@ -66,4 +66,10 @@ public protocol BuildConfiguration {
 
   /// The endianness of the target architecture.
   var endianness: Endianness? { get }
+
+  /// The effective language version, which can be set by the user (e.g., 5.0).
+  var languageVersion: VersionTuple? { get }
+
+  /// The version of the compiler (e.g., 5.9).
+  var compilerVersion: VersionTuple? { get }
 }

Sources/SwiftIfConfig/IfConfigEvaluation.swift

@@ -16,6 +16,8 @@ enum IfConfigError: Error, CustomStringConvertible {
   case unknownExpression(ExprSyntax)
   case unhandledCustomCondition(name: String, syntax: TokenSyntax)
   case unhandledFunction(name: String, syntax: ExprSyntax)
+  case unsupportedVersionOperator(name: String, operator: TokenSyntax)
+  case invalidVersionOperand(name: String, syntax: ExprSyntax)
 
   var description: String {
     switch self {
@@ -27,6 +29,12 @@ enum IfConfigError: Error, CustomStringConvertible {
 
     case .unhandledFunction(name: let name, syntax: _):
       return "build configuration cannot handle '\(name)'"
+
+    case .unsupportedVersionOperator(name: let name, operator: let op):
+      return "'\(name)' version check does not support operator '\(op.trimmedDescription)'"
+
+    case .invalidVersionOperand(name: let name, syntax: let version):
+      return "'\(name)' version check has invalid version '\(version.trimmedDescription)'"
     }
   }
 }
@@ -106,6 +114,34 @@ private func evaluateIfConfig(
       return result
     }
 
+    /// Perform a check for a version constraint as used in the "swift" or "compiler" version checks.
+    func doVersionComparisonCheck(_ actualVersion: VersionTuple?) throws -> Bool? {
+      // Ensure that we have a single unlabeled argument that is either >= or < as a prefix
+      // operator applied to a version.
+      guard let argExpr = call.argumentList.singleUnlabeledExpression,
+            let unaryArg = argExpr.as(PrefixOperatorExprSyntax.self),
+            let opToken = unaryArg.operatorToken else {
+        return nil
+      }
+
+      guard let version = VersionTuple(parsing: unaryArg.postfixExpression.trimmedDescription) else {
+        throw IfConfigError.invalidVersionOperand(name: fnName, syntax: unaryArg.postfixExpression)
+      }
+
+      guard let actualVersion else {
+        throw IfConfigError.unhandledFunction(name: fnName, syntax: argExpr)
+      }
+
+      switch opToken.text {
+      case ">=":
+        return actualVersion >= version
+      case "<":
+        return actualVersion < version
+      default:
+        throw IfConfigError.unsupportedVersionOperator(name: fnName, operator: opToken)
+      }
+    }
+
     let result: Bool?
     switch fn {
     case .hasAttribute:
@@ -165,6 +201,12 @@ private func evaluateIfConfig(
 
       result = targetPointerBitWidth == expectedPointerBitWidth
 
+    case .swift:
+      result = try doVersionComparisonCheck(configuration.languageVersion)
+
+    case .compiler:
+      result = try doVersionComparisonCheck(configuration.compilerVersion)
+
     default:
       // FIXME: Deal with all of the other kinds of checks we can perform.
       result = nil

Sources/SwiftIfConfig/VersionTuple.swift

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+/// Describes a version such as `5.9`.
+public struct VersionTuple {
+  /// The components of the version tuple, start with the major version.
+  public var components: [Int]
+}
+
+extension VersionTuple {
+  /// Create a version tuple from its components.
+  public init(_ components: Int...) {
+    self.components = components
+  }
+
+  /// Parse a string into a version tuple, returning `nil` if any errors were
+  /// present.
+  public init?(parsing string: String) {
+    self.components = []
+
+    for componentText in string.split(separator: ".") {
+      guard let component = Int(componentText) else {
+        return nil
+      }
+
+      components.append(component)
+    }
+  }
+}
+
+extension VersionTuple {
+  /// Normalize the version tuple by removing trailing zeroes.
+  var normalized: VersionTuple {
+    var newComponents = components
+    while newComponents.count > 1 && newComponents.last == 0 {
+      newComponents.removeLast()
+    }
+
+    return VersionTuple(components: newComponents)
+  }
+}
+
+extension VersionTuple: Equatable, Hashable { }
+
+extension VersionTuple: Comparable {
+  public static func <(lhs: VersionTuple, rhs: VersionTuple) -> Bool {
+    return lhs.normalized.components.lexicographicallyPrecedes(rhs.normalized.components)
+  }
+}

Tests/SwiftIfConfigTest/EvaluateTests.swift

@@ -55,6 +55,10 @@ struct TestingBuildConfiguration : BuildConfiguration {
   var targetPointerBitWidth: Int? { 64 }
 
   var endianness: SwiftIfConfig.Endianness? { .little }
+
+  var languageVersion: VersionTuple? { VersionTuple(5, 5) }
+
+  var compilerVersion: VersionTuple? { VersionTuple(5, 9) }
 }
 
 public class EvaluateTests: XCTestCase {
@@ -152,4 +156,19 @@ public class EvaluateTests: XCTestCase {
     XCTAssertEqual(try ifConfigState("_pointerBitWidth(_64)"), .active)
     XCTAssertEqual(try ifConfigState("_pointerBitWidth(_32)"), .inactive)
   }
+
+  func testVersions() throws {
+    let buildConfig = TestingBuildConfiguration()
+
+    func ifConfigState(_ condition: ExprSyntax) throws -> IfConfigState {
+      try IfConfigState(condition: condition, configuration: buildConfig)
+    }
+
+    XCTAssertEqual(try ifConfigState("swift(>=5.5"), .active)
+    XCTAssertEqual(try ifConfigState("swift(<6"), .active)
+    XCTAssertEqual(try ifConfigState("swift(>=6"), .inactive)
+    XCTAssertEqual(try ifConfigState("compiler(>=5.8"), .active)
+    XCTAssertEqual(try ifConfigState("compiler(>=5.9"), .active)
+    XCTAssertEqual(try ifConfigState("compiler(>=5.10"), .inactive)
+  }
 }