[DependencyResolver] Support Equatable on version assignment sets.

 - This also splits out the top-level resolve function which returns an assignment
   so it can be used by tests.

Author: ddunbar

Sources/PackageGraph/DependencyResolver.swift

@@ -323,25 +323,32 @@ struct PackageContainerConstraintSet<C: PackageContainer>: Collection {
 /// `constraints`, but this invariant is not explicitly enforced.
 //
 // FIXME: Actually make efficient.
-struct VersionAssignmentSet<C: PackageContainer>: Sequence {
+struct VersionAssignmentSet<C: PackageContainer>: Equatable, Sequence {
     typealias Container = C
     typealias Identifier = Container.Identifier
 
     /// The assignment records.
     //
     // FIXME: Does it really make sense to key on the identifier here. Should we
     // require referential equality of containers and use that to simplify?
-    private var assignments: [Identifier: (container: Container, binding: BoundVersion)]
+    fileprivate var assignments: [Identifier: (container: Container, binding: BoundVersion)]
 
     /// Create an empty assignment.
     init() {
         assignments = [:]
     }
 
+    /// The assignment for the given container `identifier.
+    subscript(identifier: Identifier) -> BoundVersion? {
+        get {
+            return assignments[identifier]?.binding
+        }
+    }
+
     /// The assignment for the given `container`.
     subscript(container: Container) -> BoundVersion? {
         get {
-            return assignments[container.identifier]?.binding
+            return self[container.identifier]
         }
         set {
             // We disallow deletion.
@@ -481,6 +488,18 @@ struct VersionAssignmentSet<C: PackageContainer>: Sequence {
         }
     }
 }
+func ==<C: PackageContainer>(lhs: VersionAssignmentSet<C>, rhs: VersionAssignmentSet<C>) -> Bool {
+    if lhs.assignments.count != rhs.assignments.count { return false }
+    for (container, lhsBinding) in lhs {
+        switch rhs[container] {
+        case let rhsBinding? where lhsBinding == rhsBinding:
+            continue
+        default:
+            return false
+        }
+    }
+    return true
+}
 
 /// A general purpose package dependency resolver.
 ///
@@ -567,19 +586,29 @@ public class DependencyResolver<
     /// - Returns: A satisfying assignment of containers and versions.
     /// - Throws: DependencyResolverError, or errors from the underlying package provider.
     public func resolve(constraints: [Constraint]) throws -> [(container: Identifier, version: Version)] {
+        return try resolveAssignment(constraints: constraints).map { (container, binding) in
+            guard case .version(let version) = binding else {
+                fatalError("unexpected exclude binding")
+            }
+            return (container: container.identifier, version: version)
+        }
+    }
+
+    /// Execute the resolution algorithm to find a valid assignment of versions.
+    ///
+    /// - Parameters:
+    ///   - constraints: The contraints to solve. It is legal to supply multiple
+    ///                  constraints for the same container identifier.
+    /// - Returns: A satisfying assignment of containers and versions.
+    /// - Throws: DependencyResolverError, or errors from the underlying package provider.
+    func resolveAssignment(constraints: [Constraint]) throws -> AssignmentSet {
         // Create an assignment for the input constraints.
         guard let assignment = try merge(
                 constraints: constraints, into: AssignmentSet(),
                 subjectTo: ConstraintSet(), excluding: [:]) else {
             throw DependencyResolverError.unsatisfiable
         }
-
-        return assignment.map { (container, binding) in
-            guard case .version(let version) = binding else {
-                fatalError("unexpected exclude binding")
-            }
-            return (container: container.identifier, version: version)
-        }
+        return assignment
     }
 
     /// Resolve an individual container dependency tree.

Tests/PackageGraphTests/DependencyResolverTests.swift

@@ -75,6 +75,7 @@ private class MockResolverDelegate: DependencyResolverDelegate {
 }
 
 private typealias MockDependencyResolver = DependencyResolver<MockPackagesProvider, MockResolverDelegate>
+private typealias MockVersionAssignmentSet = VersionAssignmentSet<MockPackageContainer>
 
 // Some handy ranges.
 //
@@ -172,7 +173,7 @@ class DependencyResolverTests: XCTestCase {
         let c = MockPackageContainer(name: "C", dependenciesByVersion: [
                 v1: []])
 
-        var assignment = VersionAssignmentSet<MockPackageContainer>()
+        var assignment = MockVersionAssignmentSet()
         XCTAssertEqual(assignment.constraints, [:])
         XCTAssert(assignment.isValid(binding: .version(v2), for: b))
         // An empty assignment is valid.
@@ -210,7 +211,7 @@ class DependencyResolverTests: XCTestCase {
         let d = MockPackageContainer(name: "D", dependenciesByVersion: [
                 v1: [(container: "E", versionRequirement: v1Range)],
                 v2: []])
-        var assignment2 = VersionAssignmentSet<MockPackageContainer>()
+        var assignment2 = MockVersionAssignmentSet()
         assignment2[d] = .version(v1)
         if let mergedAssignment = assignment.merging(assignment2) {
             assignment = mergedAssignment
@@ -222,12 +223,12 @@ class DependencyResolverTests: XCTestCase {
         // Check merger of an assignment with incompatible constraints.
         let d2 = MockPackageContainer(name: "D2", dependenciesByVersion: [
                 v1: [(container: "E", versionRequirement: v2Range)]])
-        var assignment3 = VersionAssignmentSet<MockPackageContainer>()
+        var assignment3 = MockVersionAssignmentSet()
         assignment3[d2] = .version(v1)
         XCTAssertEqual(assignment.merging(assignment3), nil)
 
         // Check merger of an incompatible assignment.
-        var assignment4 = VersionAssignmentSet<MockPackageContainer>()
+        var assignment4 = MockVersionAssignmentSet()
         assignment4[d] = .version(v2)
         XCTAssertEqual(assignment.merging(assignment4), nil)
     }
@@ -410,14 +411,11 @@ where C.Identifier == String
 
 private func XCTAssertEqual<C: PackageContainer>(
     _ assignment: VersionAssignmentSet<C>?,
-    _ expected: [String: Version]?,
+    _ expected: [String: Version],
     file: StaticString = #file, line: UInt = #line)
 where C.Identifier == String
 {
     if let assignment = assignment {
-        guard let expected = expected else {
-            return XCTFail("unexpected satisfying assignment (expected failure): \(assignment)", file: file, line: line)
-        }
         var actual = [String: Version]()
         for (container, binding) in assignment {
             guard case .version(let version) = binding else {
@@ -427,9 +425,7 @@ where C.Identifier == String
         }
         XCTAssertEqual(actual, expected, file: file, line: line)
     } else {
-        if let expected = expected {
-            return XCTFail("unexpected missing assignment, expected: \(expected)", file: file, line: line)
-        }
+        return XCTFail("unexpected missing assignment, expected: \(expected)", file: file, line: line)
     }
 }