[PubGrub] Add support representing disjoint version ranges

This implements support for representing disjoint version ranges so we
can properly perform Term intersection where one term is positive and
the other one is negative.

This will also unblock the infrastructure required for implementing
Package.resolved support in PubGrub.

<rdar://problem/54280439>

Author: aciidgh

Sources/PackageGraph/DependencyResolver.swift

@@ -108,129 +108,6 @@ public enum DependencyResolverError: Error, Equatable, CustomStringConvertible {
     }
 }
 
-/// An abstract definition for a set of versions.
-public enum VersionSetSpecifier: Hashable, CustomStringConvertible {
-    /// The universal set.
-    case any
-
-    /// The empty set.
-    case empty
-
-    /// A non-empty range of version.
-    case range(Range<Version>)
-
-    /// The exact version that is required.
-    case exact(Version)
-
-    /// Compute the intersection of two set specifiers.
-    public func intersection(_ rhs: VersionSetSpecifier) -> VersionSetSpecifier {
-        switch (self, rhs) {
-        case (.any, _):
-            return rhs
-        case (_, .any):
-            return self
-        case (.empty, _):
-            return .empty
-        case (_, .empty):
-            return .empty
-        case (.range(let lhs), .range(let rhs)):
-            let start = Swift.max(lhs.lowerBound, rhs.lowerBound)
-            let end = Swift.min(lhs.upperBound, rhs.upperBound)
-            if start < end {
-                return .range(start..<end)
-            } else {
-                return .empty
-            }
-        case (.exact(let v), _):
-            if rhs.contains(v) {
-                return self
-            }
-            return .empty
-        case (_, .exact(let v)):
-            if contains(v) {
-                return rhs
-            }
-            return .empty
-        }
-    }
-
-    /// Compute the intersection of two set specifiers with differing polarities.
-    ///
-    /// - Warning: It is assumed that `self` is positive and the passed set
-    ///            specifier `rhs` is negative.
-    public func intersection(withInverse rhs: VersionSetSpecifier) -> VersionSetSpecifier? {
-        switch (self, rhs) {
-        case (_, .any):
-            return nil
-        case (.any, _):
-            assertionFailure("constraints on .any are currently unexpected here")
-            // FIXME: This is incorrect, we need to return the difference here (.any - rhs),
-            // which basically means inverse of rhs but we can't return polarity from this
-            // method yet.
-            return .any
-        case (.empty, _), (_, .empty):
-            assertionFailure("constraints on .empty are currently unexpected here")
-            // TODO: Check if this is this correct.
-            return nil
-        case (.exact(let lhs), .exact(let rhs)):
-            return lhs == rhs ? nil : self
-        case (.exact(let exact), .range(let range)), (.range(let range), .exact(let exact)):
-            if range.contains(version: exact) {
-                return .range(range.lowerBound..<exact)
-            }
-            return nil
-        case (.range(let lhs), .range(let rhs)):
-            guard lhs != rhs else {
-                return nil
-            }
-            guard lhs.overlaps(rhs) else {
-                return .range(lhs)
-            }
-            if lhs.lowerBound < rhs.lowerBound {
-                return .range(lhs.lowerBound..<rhs.lowerBound)
-            } else {
-                return .range(rhs.upperBound..<lhs.upperBound)
-            }
-        }
-    }
-
-    /// Check if the set contains a version.
-    public func contains(_ version: Version) -> Bool {
-        switch self {
-        case .empty:
-            return false
-        case .range(let range):
-            return range.contains(version: version)
-        case .any:
-            return true
-        case .exact(let v):
-            return v == version
-        }
-    }
-
-    public var description: String {
-        switch self {
-        case .any:
-            return "any"
-        case .empty:
-            return "empty"
-        case .range(let range):
-            var upperBound = range.upperBound
-            // Patch the version range representation. This shouldn't be
-            // required once we have custom version range structure.
-            if upperBound.minor == .max && upperBound.patch == .max {
-                upperBound = Version(upperBound.major + 1, 0, 0)
-            }
-            if upperBound.minor != .max && upperBound.patch == .max {
-                upperBound = Version(upperBound.major, upperBound.minor + 1, 0)
-            }
-            return range.lowerBound.description + "..<" + upperBound.description
-        case .exact(let version):
-            return version.description
-        }
-    }
-}
-
 /// A requirement that a package must satisfy.
 public enum PackageRequirement: Hashable {
 

Sources/PackageGraph/Pubgrub.swift

@@ -71,22 +71,16 @@ public struct Term: Equatable, Hashable {
         let isPositive: Bool
         switch (self.isPositive, otherIsPositive) {
         case (false, false):
-            if case .range(let lhs) = lhs, case .range(let rhs) = rhs {
-                let lower = min(lhs.lowerBound, rhs.lowerBound)
-                let upper = max(lhs.upperBound, rhs.upperBound)
-                intersection = .range(lower..<upper)
-            } else {
-                intersection = lhs.intersection(rhs)
-            }
+            intersection = lhs.union(rhs)
             isPositive = false
         case (true, true):
             intersection = lhs.intersection(rhs)
             isPositive = true
         case (true, false):
-            intersection = lhs.intersection(withInverse: rhs)
+            intersection = lhs.difference(rhs)
             isPositive = true
         case (false, true):
-            intersection = rhs.intersection(withInverse: lhs)
+            intersection = rhs.difference(lhs)
             isPositive = true
         }
 
@@ -184,20 +178,7 @@ extension VersionSetSpecifier {
 extension Term: CustomStringConvertible {
     public var description: String {
         let pkg = "\(package)"
-        var req = ""
-
-        let vs = requirement
-            switch vs {
-            case .any:
-                req = "*"
-            case .empty:
-                req = "()"
-            case .exact(let v):
-                req = v.description
-            case .range(let range):
-                req = range.description
-            }
-
+        let req = requirement.description
 
         if !isPositive {
             return "¬\(pkg) \(req)"
@@ -224,7 +205,10 @@ public struct Incompatibility: Equatable, Hashable {
     }
 
     init(_ terms: OrderedSet<Term>, root: PackageReference, cause: Cause) {
-        assert(terms.count > 0, "An incompatibility must contain at least one term.")
+        if terms.isEmpty {
+            self.init(terms: terms, cause: cause)
+            return
+        }
 
         // Remove the root package from generated incompatibilities, since it will
         // always be selected.
@@ -1000,7 +984,7 @@ public final class PubgrubDependencyResolver {
             switch assignment.term.requirement {
             case .exact(let version):
                 boundVersion = .version(version)
-            case .range, .any, .empty:
+            case .range, .any, .empty, .ranges:
                 fatalError("unexpected requirement value for assignment \(assignment.term)")
             }
 
@@ -1197,7 +1181,7 @@ public final class PubgrubDependencyResolver {
     /// failed, meaning this incompatibility is either empty or only for the root
     /// package.
     private func isCompleteFailure(_ incompatibility: Incompatibility) -> Bool {
-        return incompatibility.terms.count == 1 && incompatibility.terms.first?.package == root
+        return incompatibility.terms.isEmpty || (incompatibility.terms.count == 1 && incompatibility.terms.first?.package == root)
     }
 
     struct DependencyIncompatibilityError: Swift.Error {
@@ -1230,7 +1214,7 @@ public final class PubgrubDependencyResolver {
 
             let requirement: VersionSetSpecifier
             switch pkgTerm.requirement {
-            case .any, .empty, .exact:
+            case .any, .empty, .exact, .ranges:
                 requirement = pkgTerm.requirement
             case .range(let range):
                 // FIXME: This isn't really correct. How do we figure out the exact upper bound?
@@ -1353,6 +1337,7 @@ public final class PubgrubDependencyResolver {
             // resolution errors properly. We only end up showing the
             // the problem with the oldest version.
             let nextMajor = Version(version.major + 1, 0, 0)
+//            terms.append(Term(container.identifier, .exact(version)))
             terms.append(Term(container.identifier, .range(version..<nextMajor)))
             terms.append(Term(not: dep.identifier, vs))
             return Incompatibility(terms, root: root!, cause: .dependency(package: container.identifier))
@@ -1659,6 +1644,9 @@ final class DiagnosticReportBuilder {
                 } else {
                     return "\(name) \(range.description)"
                 }
+
+            case .ranges(let ranges):
+                return "\(name) \(ranges)"
             }
         }
 
@@ -1694,7 +1682,7 @@ extension BoundVersion {
 extension VersionSetSpecifier {
     fileprivate var isExact: Bool {
         switch self {
-        case .any, .empty, .range:
+        case .any, .empty, .range, .ranges:
             return false
         case .exact:
             return true
@@ -1721,3 +1709,9 @@ extension PackageRequirement {
         }
     }
 }
+
+extension Version {
+    func nextPatch() -> Version {
+        return Version(major, minor, patch + 1)
+    }
+}