Generalize Linkage Testing Infrastructure

CodaFi · CodaFi · commit 33a5e762eeb1 · 2022-09-20T11:08:41.000-07:00
Allow for linkage conditions based on the language version and build configuration.
diff --git a/Tests/SwiftParserTest/Linkage.swift b/Tests/SwiftParserTest/Linkage.swift
@@ -9,6 +9,85 @@ final class LinkageTest: XCTestCase {
   // a SwiftSyntax maintainer to see if there's a way to avoid adding the
   // dependency.
   func testLinkage() throws {
+    guard let baseURL = try self.findEnclosingTestBundle() else {
+      XCTFail("Unable to determine path to enclosing xctest bundle")
+      return
+    }
+
+    let swiftSyntaxURL = baseURL.appendingPathComponent("SwiftSyntax.o")
+    try assertLinkage(of: swiftSyntaxURL, assertions: [
+      .library("-lobjc"),
+      .library("-lswiftCompatibility51", condition: .mayBeAbsent("Starting in Xcode 14 this library is not always autolinked")),
+      .library("-lswiftCompatibilityConcurrency"),
+      .library("-lswiftCore"),
+      .library("-lswiftDarwin"),
+      .library("-lswiftSwiftOnoneSupport", condition: .when(configuration: .debug)),
+      .library("-lswift_Concurrency"),
+      .library("-lswift_StringProcessing", condition: .when(swiftVersionAtLeast: .v5_7)),
+    ])
+
+    let swiftParserURL = baseURL.appendingPathComponent("SwiftParser.o")
+    try assertLinkage(of: swiftParserURL, assertions: [
+      .library("-lobjc"),
+      .library("-lswiftCompatibility51", condition: .mayBeAbsent("Starting in Xcode 14 this library is not always autolinked")),
+      .library("-lswiftCompatibilityConcurrency"),
+      .library("-lswiftCore"),
+      .library("-lswiftDarwin"),
+      .library("-lswiftSwiftOnoneSupport", condition: .when(configuration: .debug)),
+      .library("-lswift_Concurrency"),
+      .library("-lswift_StringProcessing", condition: .when(swiftVersionAtLeast: .v5_7)),
+    ])
+  }
+
+  private func assertLinkage(
+    of object: URL,
+    assertions: [Linkage.Assertion]
+  ) throws {
+    let linkages = try self.extractLinkages(from: object)
+
+    let sortedLinkages = Set(linkages).sorted()
+    var expectedLinkagesIdx = sortedLinkages.startIndex
+    var assertions = assertions.makeIterator()
+    while let assert = assertions.next() {
+      // Evaluate the condition first, if any.
+      if let condition = assert.condition, !condition.evaluate() {
+        continue
+      }
+
+      // Make sure there's a linkage to even assert against. If not, then we've
+      // got too many assertions and not enough link libraries. This isn't
+      // always a bad thing, but it's worth calling out so we document this
+      // with `.mayBeAbsent(...)`.
+      guard expectedLinkagesIdx < sortedLinkages.endIndex else {
+        XCTFail("Expected linkage was not present: \(assert.linkage)",
+                file: assert.file, line: assert.line)
+        continue
+      }
+
+      let linkage = sortedLinkages[expectedLinkagesIdx]
+
+      // Check the linkage assertion. If it doesn't hold, the real fun begins.
+      guard !assert.matches(linkage) else {
+        expectedLinkagesIdx += 1
+        continue
+      }
+
+      // Skip flaky linkages if they're absent.
+      if case .flaky = assert.condition {
+        continue
+      }
+
+      XCTFail("Expected linkage to \(assert.linkage), but recieved linkage to \(linkage.linkage); Perhaps linkage assertions are out of order?",
+              file: assert.file, line: assert.line)
+      expectedLinkagesIdx += 1
+    }
+
+    for superfluousLinkage in sortedLinkages[expectedLinkagesIdx..<sortedLinkages.endIndex] {
+      XCTFail("Found unasserted link-time dependency: \(superfluousLinkage.linkage)")
+    }
+  }
+
+  private func findEnclosingTestBundle() throws -> URL? {
     for i in 0..<_dyld_image_count() {
       let name = try XCTUnwrap(_dyld_get_image_name(i))
       let path = String(cString: name)
@@ -22,39 +101,12 @@ final class LinkageTest: XCTestCase {
       }
 
       if baseURL.pathComponents.isEmpty {
-        XCTFail("Unable to determine path to enclosing xctest bundle")
-        return
+        continue
       }
 
-      baseURL = baseURL.deletingLastPathComponent()
-      let swiftSyntaxURL = baseURL.appendingPathComponent("SwiftSyntax.o")
-      try assertLinkage(of: swiftSyntaxURL) { linkages in
-        XCTAssertEqual(linkages, [
-          .library("-lobjc"),
-          .library("-lswiftCompatibilityConcurrency"),
-          .library("-lswiftCore"),
-          .library("-lswiftDarwin"),
-          .library("-lswiftSwiftOnoneSupport"),
-          .library("-lswift_Concurrency"),
-        ])
-      }
-      let swiftParserURL = baseURL.appendingPathComponent("SwiftParser.o")
-      try assertLinkage(of: swiftParserURL) { linkages in
-        XCTAssertEqual(linkages, [
-          .library("-lobjc"),
-          .library("-lswiftCompatibilityConcurrency"),
-          .library("-lswiftCore"),
-          .library("-lswiftDarwin"),
-          .library("-lswiftSwiftOnoneSupport"),
-          .library("-lswift_Concurrency"),
-        ])
-      }
+      return baseURL.deletingLastPathComponent()
     }
-  }
-
-  private enum Linkage: Comparable {
-    case library(String)
-    case framework(String)
+    return nil
   }
 
   private func readLoadCommands(in object: URL) throws -> [String] {
@@ -75,14 +127,35 @@ final class LinkageTest: XCTestCase {
     return output.components(separatedBy: .newlines)
   }
 
-  private func assertLinkage(of object: URL, assertion: ([Linkage]) throws -> Void) throws {
+  private func extractLinkages(from object: URL) throws -> [Linkage] {
     var linkages = [Linkage]()
     var lines = try self.readLoadCommands(in: object).makeIterator()
     while let line = lines.next() {
       guard line.starts(with: "Load command") else {
         continue
       }
 
+      // The load commands we're interested in are all autolinking hints of the
+      // following form:
+      //
+      // ```
+      // Load command <N>
+      //      cmd LC_LINKER_OPTION
+      //  cmdsize <N>
+      //    count 1
+      //   string #1 -l<lib>
+      // ```
+      //
+      // Or
+      //
+      // ```
+      // Load command <N>
+      //      cmd LC_LINKER_OPTION
+      //  cmdsize <N>
+      //    count 2
+      //   string #1 -framework
+      //   string #2 Foundation
+      // ```
       guard
         let command = lines.next(),
         command.hasSuffix("LC_LINKER_OPTION"),
@@ -96,13 +169,13 @@ final class LinkageTest: XCTestCase {
         .suffix(from: count.index(count.startIndex, offsetBy: "count ".count))
       guard let count = Int(countString), count == 1 || count == 2 else {
         XCTFail("Malformed load command: \(line)")
-        return
+        return linkages
       }
 
       if count == 1 {
         guard let library = lines.next() else {
           XCTFail("No load command payload: \(line)")
-          return
+          return linkages
         }
 
         let linkLibrary = library.trimmingCharacters(in: .whitespaces)
@@ -116,15 +189,109 @@ final class LinkageTest: XCTestCase {
           let framework = lines.next()
         else {
           XCTFail("No load command payload: \(line)")
-          return
+          return linkages
         }
 
         let linkedFramework = framework.trimmingCharacters(in: .whitespaces)
           .suffix(from: framework.index(framework.startIndex, offsetBy: "string #2 ".count))
         linkages.append(.framework(String(linkedFramework)))
       }
     }
-    return try assertion(linkages.sorted())
+    return linkages
   }
 }
 #endif
+
+fileprivate enum Linkage: Comparable, Hashable {
+  case library(String)
+  case framework(String)
+
+  var linkage: String {
+    switch self {
+    case .library(let s): return s
+    case .framework(let s): return s
+    }
+  }
+
+  func hasPrefix(_ prefix: String) -> Bool {
+    return self.linkage.hasPrefix(prefix)
+  }
+}
+
+extension Linkage {
+  fileprivate struct Assertion {
+    var linkage: Linkage
+    var condition: Condition?
+    var file: StaticString
+    var line: UInt
+
+    func matches(_ linkage: Linkage) -> Bool {
+      return self.linkage == linkage
+    }
+
+    static func library(_ linkage: String, condition: Condition? = nil, file: StaticString = #file, line: UInt = #line) -> Assertion {
+      return Linkage.Assertion(linkage: .library(linkage), condition: condition, file: file, line: line)
+    }
+
+    static func framework(_ linkage: String, condition: Condition? = nil, file: StaticString = #file, line: UInt = #line) -> Assertion {
+      return Linkage.Assertion(linkage: .framework(linkage), condition: condition, file: file, line: line)
+    }
+  }
+}
+
+extension Linkage.Assertion {
+  fileprivate enum Condition {
+    case swiftVersionAtLeast(versionBound: SwiftVersion)
+    case configuration(ProductConfiguration)
+    case flaky
+
+    enum SwiftVersion: Comparable {
+      case v5_5
+      case v5_6
+      case v5_7
+      // We don't support compiling with <=5.4
+    }
+
+    enum ProductConfiguration: Equatable {
+      case debug
+      case release
+    }
+
+    fileprivate static func when(swiftVersionAtLeast version: SwiftVersion) -> Condition {
+      return .swiftVersionAtLeast(versionBound: version)
+    }
+
+    fileprivate static func when(configuration: ProductConfiguration) -> Condition {
+      return .configuration(configuration)
+    }
+
+    fileprivate static func mayBeAbsent(_ reason: StaticString) -> Condition {
+      return .flaky
+    }
+
+    fileprivate func evaluate() -> Bool {
+      switch self {
+      case let .swiftVersionAtLeast(versionBound: bound):
+#if swift(>=5.7)
+        let version: SwiftVersion = .v5_7
+#elseif swift(>=5.6)
+        let version: SwiftVersion = .v5_6
+#elseif swift(>=5.5)
+        let version: SwiftVersion = .v5_5
+#else
+        #error("Swift version is too old!")
+#endif
+        return version >= bound
+      case let .configuration(expectation):
+#if DEBUG
+        let config: ProductConfiguration = .debug
+#else
+        let config: ProductConfiguration = .release
+#endif
+        return config == expectation
+      case .flaky:
+        return true
+      }
+    }
+  }
+}
