[PubGrub] Expand provided library resolution tests

Since provided libraries are now returned from resultion we
need to double-check if resultion returns proper package reference
kinds for packages with provided libraries.

Author: xedin

Sources/PackageGraph/CMakeLists.txt

@@ -20,6 +20,7 @@ add_library(PackageGraph
   PackageModel+Extensions.swift
   PackageRequirement.swift
   PinsStore.swift
+  ProvidedLibraryPackageContainer.swift
   Resolution/PubGrub/Assignment.swift
   Resolution/PubGrub/ContainerProvider.swift
   Resolution/PubGrub/DiagnosticReportBuilder.swift

Sources/Workspace/PackageContainer/ProvidedLibraryPackageContainer.swift renamed to Sources/PackageGraph/ProvidedLibraryPackageContainer.swift

@@ -12,12 +12,13 @@
 
 import Basics
 import Dispatch
-import PackageGraph
 import PackageLoading
 import PackageModel
 
 import struct TSCUtility.Version
 
+/// TODO: This could be removed once logic to handle provided libraries is integrated
+/// into a \c PubGrubPackageContainer.
 public struct ProvidedLibraryPackageContainer: PackageContainer {
     public let package: PackageReference
 

Sources/PackageGraph/Resolution/PubGrub/ContainerProvider.swift

@@ -97,6 +97,14 @@ final class ContainerProvider {
             ) { result in
                 let result = result.tryMap { container -> PubGrubPackageContainer in
                     let pubGrubContainer = PubGrubPackageContainer(underlying: container, pins: self.pins)
+
+                    // This container is not cached because it's intended to be transparent
+                    // and requested only when forming final assignments. Caching it would
+                    // mean that subsequent calls to `solve` would pick it up.
+                    if case .providedLibrary = package.kind {
+                        return pubGrubContainer
+                    }
+
                     // only cache positive results
                     self.containersCache[package] = pubGrubContainer
                     return pubGrubContainer

Sources/Workspace/CMakeLists.txt

@@ -15,7 +15,6 @@ add_library(Workspace
   ManagedArtifact.swift
   ManagedDependency.swift
   PackageContainer/FileSystemPackageContainer.swift
-  PackageContainer/ProvidedLibraryPackageContainer.swift
   PackageContainer/RegistryPackageContainer.swift
   PackageContainer/SourceControlPackageContainer.swift
   ResolvedFileWatcher.swift

Sources/Workspace/Workspace+Dependencies.swift

@@ -33,6 +33,7 @@ import struct PackageGraph.ObservabilityDependencyResolverDelegate
 import struct PackageGraph.PackageContainerConstraint
 import struct PackageGraph.PackageGraphRoot
 import struct PackageGraph.PackageGraphRootInput
+import struct PackageGraph.ProvidedLibraryPackageContainer
 import class PackageGraph.PinsStore
 import struct PackageGraph.PubGrubDependencyResolver
 import struct PackageGraph.Term

Sources/Workspace/Workspace+PackageContainer.swift

@@ -17,6 +17,7 @@ import enum PackageFingerprint.FingerprintCheckingMode
 import enum PackageGraph.ContainerUpdateStrategy
 import protocol PackageGraph.PackageContainer
 import protocol PackageGraph.PackageContainerProvider
+import struct PackageGraph.ProvidedLibraryPackageContainer
 import struct PackageModel.PackageReference
 
 // MARK: - Package container provider

Tests/PackageGraphTests/PubgrubTests.swift

@@ -2044,12 +2044,18 @@ final class PubGrubTestsBasicGraphs: XCTestCase {
         ])
 
         let result = resolver.solve(constraints: dependencies1)
-        // Available libraries are filtered from the resolver results, so this is expected to be empty.
-        AssertResult(result, [])
+        print(try result.get())
+        AssertResult(result, [
+            (
+                "foo",
+                .providedLibrary(.init("https://example.com/org/foo"), .init("/foo")),
+                .version(.init(stringLiteral: "1.0.0"))
+            ),
+        ])
 
         let result2 = resolver.solve(constraints: dependencies2)
         AssertResult(result2, [
-            ("foo", .version(.init(stringLiteral: "1.2.0"))),
+            ("foo", fooRef.kind, .version(.init(stringLiteral: "1.2.0"))),
         ])
     }
 
@@ -2101,14 +2107,23 @@ final class PubGrubTestsBasicGraphs: XCTestCase {
             "target": (.versionSet(.range(.upToNextMajor(from: "2.0.0"))), .everything),
         ])
 
-        // This behavior requires an explanation - "foo" is elided because 1.1.0 is prebuilt.
-        // It matches "root" requirements but without prebuilt library the solver would pick
-        // "1.0.0" because "foo" 1.1.0 dependency version requirements are incompatible with
-        // "target" 2.0.0.
+        // This behavior requires an explanation - "foo" is selected to be 1.1.0 because its
+        // prebuilt matches "root" requirements but without prebuilt library the solver would
+        // pick "1.0.0" because "foo" 1.1.0 dependency version requirements are incompatible
+        // with "target" 2.0.0.
 
         let result = resolver.solve(constraints: dependencies)
         AssertResult(result, [
-            ("target", .version(.init(stringLiteral: "2.0.0"))),
+            (
+                "foo",
+                .providedLibrary(.init("https://example.com/org/foo"), .init("/foo")),
+                .version(.init(stringLiteral: "1.1.0"))
+            ),
+            (
+                "target",
+                .localSourceControl("/target"),
+                .version(.init(stringLiteral: "2.0.0"))
+            ),
         ])
     }
 
@@ -2152,8 +2167,8 @@ final class PubGrubTestsBasicGraphs: XCTestCase {
 
         let result = resolver.solve(constraints: dependencies)
         AssertResult(result, [
-            ("foo", .version(.init(stringLiteral: "1.1.0"))),
-            ("bar", .version(.init(stringLiteral: "1.0.0"))),
+            ("foo", fooRef.kind, .version(.init(stringLiteral: "1.1.0"))),
+            ("bar", .localSourceControl("/bar"), .version(.init(stringLiteral: "1.0.0"))),
         ])
     }
 }
@@ -3297,6 +3312,22 @@ private func AssertBindings(
     _ packages: [(identity: PackageIdentity, version: BoundVersion)],
     file: StaticString = #file,
     line: UInt = #line
+) {
+    AssertBindings(
+        bindings,
+        packages.map {
+            (identity: $0, kind: nil, version: $1)
+        },
+        file: file,
+        line: line
+    )
+}
+
+private func AssertBindings(
+    _ bindings: [DependencyResolverBinding],
+    _ packages: [(identity: PackageIdentity, kind: PackageReference.Kind?, version: BoundVersion)],
+    file: StaticString = #file,
+    line: UInt = #line
 ) {
     if bindings.count > packages.count {
         let unexpectedBindings = bindings
@@ -3314,7 +3345,17 @@ private func AssertBindings(
         )
     }
     for package in packages {
-        guard let binding = bindings.first(where: { $0.package.identity == package.identity }) else {
+        guard let binding = bindings.first(where: {
+            if $0.package.identity != package.identity {
+                return false
+            }
+
+            if let kind = package.kind, $0.package.kind != kind {
+                return false
+            }
+
+            return true
+        }) else {
             XCTFail("No binding found for \(package.identity).", file: file, line: line)
             continue
         }
@@ -3335,10 +3376,24 @@ private func AssertResult(
     _ packages: [(identifier: String, version: BoundVersion)],
     file: StaticString = #file,
     line: UInt = #line
+) {
+    AssertResult(result, packages.map { ($0, nil, $1) }, file: file, line: line)
+}
+
+private func AssertResult(
+    _ result: Result<[DependencyResolverBinding], Error>,
+    _ packages: [(identifier: String, kind: PackageReference.Kind?, version: BoundVersion)],
+    file: StaticString = #file,
+    line: UInt = #line
 ) {
     switch result {
     case .success(let bindings):
-        AssertBindings(bindings, packages.map { (PackageIdentity($0.identifier), $0.version) }, file: file, line: line)
+        AssertBindings(
+            bindings,
+            packages.map { (PackageIdentity($0.identifier), $0.kind, $0.version) },
+            file: file,
+            line: line
+        )
     case .failure(let error):
         XCTFail("Unexpected error: \(error)", file: file, line: line)
     }
@@ -3544,6 +3599,18 @@ public struct MockProvider: PackageContainerProvider {
         ) -> Void
     ) {
         queue.async {
+            if case .providedLibrary(_, _) = package.kind {
+                do {
+                    let container = try ProvidedLibraryPackageContainer(
+                        package: package,
+                        observabilityScope: observabilityScope
+                    )
+                    return completion(.success(container))
+                } catch {
+                    return completion(.failure(error))
+                }
+            }
+
             completion(
                 self.containersByIdentifier[package].map { .success($0) } ??
                     .failure(_MockLoadingError.unknownModule)