Fix VersionSetSpecifier (#5725)

This fixes two issues:
- `difference` had a bug where the difference of 0.x.0..<0.x.1 and 0.x.0 was 0.x.1 instead of `.empty` -- I am actually unsure what the difference of empty and 0.x.0 is supposed to be, but I am keeping it as `.empty` since we have a test for that case
- `equals` was using the default implementation, but there are several cases that should be equal but aren't -- one of them came into play in the problem I was looking at, namely a range spanning a single version and an exact version should be considered equal

rdar://98452796

Author: neonichu

Sources/PackageGraph/VersionSetSpecifier.swift

@@ -30,6 +30,57 @@ public enum VersionSetSpecifier: Hashable {
     case ranges([Range<Version>])
 }
 
+extension VersionSetSpecifier: Equatable {
+    public static func ==(lhs: VersionSetSpecifier, rhs: VersionSetSpecifier) -> Bool {
+        switch (lhs, rhs) {
+        // Basic cases.
+        case (.any, .any):
+            return true
+        case (.empty, .empty):
+            return true
+        case (let .range(lhsRange), let .range(rhsRange)):
+            return lhsRange == rhsRange
+        case (let .exact(lhsExact), let .exact(rhsExact)):
+            return lhsExact == rhsExact
+        case (let .ranges(lhsRanges), let .ranges(rhsRanges)):
+            return lhsRanges == rhsRanges
+
+        // Empty is equivalent to an empty list of ranges or if the list contains one range where the lower bound equals the upper bound.
+        case (.empty, let .ranges(ranges)):
+            fallthrough
+        case (let .ranges(ranges), .empty):
+            return ranges.isEmpty || (ranges.count == 1 && ranges[0].lowerBound == ranges[0].upperBound)
+
+        // Empty is equivalent to a range where the lower bound equals the upper bound.
+        case (.empty, let .range(range)):
+            fallthrough
+        case (let .range(range), .empty):
+            return range.upperBound == range.lowerBound
+
+        // Exact is equal to a range that spans a single patch.
+        case (let .exact(exact), let .range(range)):
+            fallthrough
+        case (let .range(range), let .exact(exact)):
+            return range.lowerBound == exact && range.upperBound == exact.nextPatch()
+
+        // Exact is also equal to a list of ranges with one entry that spans a single patch.
+        case (let .exact(exact), let .ranges(ranges)):
+            fallthrough
+        case (let .ranges(ranges), let .exact(exact)):
+            return ranges.count == 1 && ranges[0].lowerBound == exact && ranges[0].upperBound == exact.nextPatch()
+
+        // A range is equal to a list of ranges with that one range.
+        case (let .range(range), let .ranges(ranges)):
+            fallthrough
+        case (let .ranges(ranges), let .range(range)):
+            return ranges.count == 1 && ranges[0] == range
+
+        default:
+            return false
+        }
+    }
+}
+
 extension VersionSetSpecifier {
     var isExact: Bool {
         switch self {
@@ -225,8 +276,8 @@ extension VersionSetSpecifier {
             }
 
             if lhs.lowerBound == rhs {
-                // Return empty if the range represents the exact version.
-                if lhs.lowerBound == lhs.upperBound {
+                // Return empty if the range represents the exact version or the range is empty.
+                if lhs.lowerBound == lhs.upperBound || lhs.lowerBound.nextPatch() == lhs.upperBound {
                     return .empty
                 }
                 return .range(rhs.nextPatch()..<lhs.upperBound)

Tests/PackageGraphTests/VersionSetSpecifierTests.swift

@@ -59,6 +59,7 @@ final class VersionSetSpecifierTests: XCTestCase {
         XCTAssertEqual(VersionSetSpecifier.range("1.0.0"..<"2.0.0").difference(.exact("1.0.0")), .range("1.0.1"..<"2.0.0"))
         XCTAssertEqual(VersionSetSpecifier.range("1.0.0"..<"2.0.0").difference(.exact("1.5.0")), .ranges(["1.0.0"..<"1.5.0", "1.5.1"..<"2.0.0"]))
         XCTAssertEqual(VersionSetSpecifier.range("2.0.0"..<"2.0.0").difference(.exact("2.0.0")), .empty)
+        XCTAssertEqual(VersionSetSpecifier.range("2.0.0"..<"2.0.1").difference(.exact("2.0.0")), .empty)
 
         XCTAssertEqual(VersionSetSpecifier.exact("1.0.0").difference(.range("1.0.0"..<"2.0.0")), .empty)
         XCTAssertEqual(VersionSetSpecifier.exact("3.0.0").difference(.range("1.0.0"..<"2.0.0")), .exact("3.0.0"))
@@ -99,4 +100,35 @@ final class VersionSetSpecifierTests: XCTestCase {
         XCTAssertEqual(VersionSetSpecifier.ranges(["3.2.0"..<"3.2.3", "3.2.4"..<"4.0.0"]).difference(.exact("3.2.2")), .ranges(["3.2.0"..<"3.2.2", "3.2.4"..<"4.0.0"]))
         XCTAssertEqual(VersionSetSpecifier.ranges(["3.2.0"..<"3.2.1", "3.2.3"..<"4.0.0"]).difference(.exact("3.2.0")), .range("3.2.3"..<"4.0.0"))
     }
+
+    func testEquality() {
+        // Basic cases.
+        XCTAssertTrue(VersionSetSpecifier.any == VersionSetSpecifier.any)
+        XCTAssertTrue(VersionSetSpecifier.empty == VersionSetSpecifier.empty)
+        XCTAssertTrue(VersionSetSpecifier.range("1.0.0"..<"5.0.0") == VersionSetSpecifier.range("1.0.0"..<"5.0.0"))
+        XCTAssertTrue(VersionSetSpecifier.exact("1.2.3") == VersionSetSpecifier.exact("1.2.3"))
+        XCTAssertTrue(VersionSetSpecifier.ranges(["3.2.0"..<"3.2.1", "3.2.3"..<"4.0.0"]) == VersionSetSpecifier.ranges(["3.2.0"..<"3.2.1", "3.2.3"..<"4.0.0"]))
+
+        // Empty is equivalent to an empty list of ranges or if the list contains one range where the lower bound equals the upper bound./
+        XCTAssertTrue(VersionSetSpecifier.empty == VersionSetSpecifier.ranges([]))
+        XCTAssertTrue(VersionSetSpecifier.ranges([]) == VersionSetSpecifier.empty)
+        XCTAssertTrue(VersionSetSpecifier.empty == VersionSetSpecifier.ranges(["2.0.0"..<"2.0.0"]))
+        XCTAssertTrue(VersionSetSpecifier.ranges(["2.0.0"..<"2.0.0"]) == VersionSetSpecifier.empty)
+
+        // Empty is equivalent to a range where the lower bound equals the upper bound.
+        XCTAssertTrue(VersionSetSpecifier.empty == VersionSetSpecifier.range("2.0.0"..<"2.0.0"))
+        XCTAssertTrue(VersionSetSpecifier.range("2.0.0"..<"2.0.0") == VersionSetSpecifier.empty)
+
+        // Exact is equal to a range that spans a single patch.
+        XCTAssertTrue(VersionSetSpecifier.exact("2.0.1") == VersionSetSpecifier.range("2.0.1"..<"2.0.2"))
+        XCTAssertTrue(VersionSetSpecifier.range("2.0.1"..<"2.0.2") == VersionSetSpecifier.exact("2.0.1"))
+
+        // Exact is also equal to a list of ranges with one entry that spans a single patch.
+        XCTAssertTrue(VersionSetSpecifier.exact("2.0.1") == VersionSetSpecifier.ranges(["2.0.1"..<"2.0.2"]))
+        XCTAssertTrue(VersionSetSpecifier.ranges(["2.0.1"..<"2.0.2"]) == VersionSetSpecifier.exact("2.0.1"))
+
+        // A range is equal to a list of ranges with that one range.
+        XCTAssertTrue(VersionSetSpecifier.range("2.0.1"..<"2.0.2") == VersionSetSpecifier.ranges(["2.0.1"..<"2.0.2"]))
+        XCTAssertTrue(VersionSetSpecifier.ranges(["2.0.1"..<"2.0.2"]) == VersionSetSpecifier.range("2.0.1"..<"2.0.2"))
+    }
 }