[Resolution/Loading] Handle packages backed by a provided library

Instead of eliding provided library packages, start returning them
from resolution as a special `.providedLibrary` reference and augment
manifest loader to build manifests for such libraries based on contents
of the library's directory (each `.swiftmodule` becomes a
`.providedLibrary` target).

Author: xedin

Sources/PackageGraph/Resolution/PubGrub/PubGrubDependencyResolver.swift

@@ -231,7 +231,7 @@ public struct PubGrubDependencyResolver {
                 continue
             }
 
-            let package = assignment.term.node.package
+            var package = assignment.term.node.package
 
             let boundVersion: BoundVersion
             switch assignment.term.requirement {
@@ -241,16 +241,18 @@ public struct PubGrubDependencyResolver {
                 throw InternalError("unexpected requirement value for assignment \(assignment.term)")
             }
 
-            // Strip packages that have prebuilt libraries only if they match library version.
-            //
-            // FIXME: This is built on assumption that libraries are part of the SDK and are
-            //        always available in include/library paths, but what happens if they are
-            //        part of a toolchain instead? Builder needs an indicator that certain path
-            //        has to be included when building packages that depend on prebuilt libraries.
             if let library = package.matchingPrebuiltLibrary(in: availableLibraries),
                boundVersion == .version(.init(stringLiteral: library.version))
             {
-                continue
+                guard case .remoteSourceControl(let url) = package.kind else {
+                    throw InternalError("Matched provided library against invalid package: \(package)")
+                }
+
+                package = .providedLibrary(
+                    identity: package.identity,
+                    origin: url,
+                    path: library.location
+                )
             }
 
             let products = assignment.term.node.productFilter

Sources/PackageLoading/ManifestLoader+Validation.swift

@@ -34,6 +34,11 @@ public struct ManifestValidator {
 
     /// Validate the provided manifest.
     public func validate() -> [Basics.Diagnostic] {
+        // Provided library manifest is synthesized by the package manager.
+        if case .providedLibrary =  self.manifest.packageKind {
+            return []
+        }
+
         var diagnostics = [Basics.Diagnostic]()
 
         diagnostics += self.validateTargets()

Sources/PackageLoading/ManifestLoader.swift

@@ -206,6 +206,19 @@ extension ManifestLoaderProtocol {
         completion: @escaping (Result<Manifest, Error>) -> Void
     ) {
         do {
+            if case .providedLibrary = packageKind {
+                let manifest = try self.loadLibrary(
+                    fileSystem: fileSystem,
+                    packagePath: packagePath,
+                    packageKind: packageKind,
+                    packageIdentity: packageIdentity,
+                    packageLocation: packageLocation,
+                    packageVersion: packageVersion?.version
+                )
+                completion(.success(manifest))
+                return
+            }
+
             // find the manifest path and parse it's tools-version
             let manifestPath = try ManifestLoader.findManifest(packagePath: packagePath, fileSystem: fileSystem, currentToolsVersion: currentToolsVersion)
             let manifestToolsVersion = try ToolsVersionParser.parse(manifestPath: manifestPath, fileSystem: fileSystem)
@@ -266,6 +279,53 @@ extension ManifestLoaderProtocol {
             )
         }
     }
+
+    private func loadLibrary(
+        fileSystem: FileSystem,
+        packagePath: AbsolutePath,
+        packageKind: PackageReference.Kind,
+        packageIdentity: PackageIdentity,
+        packageLocation: String,
+        packageVersion: Version?
+    ) throws -> Manifest {
+        let names = try fileSystem.getDirectoryContents(packagePath).filter {
+            $0.hasSuffix("swiftmodule")
+        }.map {
+            let components = $0.split(separator: ".")
+            return String(components[0])
+        }
+
+        let products: [ProductDescription] = try names.map {
+            try .init(name: $0, type: .library(.automatic), targets: [$0])
+        }
+
+        let targets: [TargetDescription] = try names.map {
+            try .init(
+                name: $0,
+                path: packagePath.pathString,
+                type: .providedLibrary
+            )
+        }
+
+        return .init(
+            displayName: packageIdentity.description,
+            path: packagePath.appending(component: "provided-libraries.json"),
+            packageKind: packageKind,
+            packageLocation: packageLocation,
+            defaultLocalization: nil,
+            platforms: [],
+            version: packageVersion,
+            revision: nil,
+            toolsVersion: .v6_0,
+            pkgConfig: nil,
+            providers: nil,
+            cLanguageStandard: nil,
+            cxxLanguageStandard: nil,
+            swiftLanguageVersions: nil,
+            products: products,
+            targets: targets
+        )
+    }
 }
 
 // MARK: - ManifestLoader