Implement package resolution through a registry

Author: mattt

Sources/PackageGraph/PackageGraph+Loading.swift

@@ -231,7 +231,7 @@ private func createResolvedPackages(
         var dependenciesByNameForTargetDependencyResolution = [String: ResolvedPackageBuilder]()
 
         // Establish the manifest-declared package dependencies.
-        package.manifest.dependenciesRequired(for: packageBuilder.productFilter).forEach { dependency in
+        try package.manifest.dependenciesRequired(for: packageBuilder.productFilter).forEach { dependency in
             // FIXME: change this validation logic to use identity instead of location
             let dependencyLocation: String
             switch dependency {
@@ -244,9 +244,12 @@ private func createResolvedPackages(
                 case .remote(let url):
                     dependencyLocation = url.absoluteString
                 }
-            case .registry:
-                // FIXME
-                fatalError("registry based dependencies not implemented yet")
+            case .registry(let settings):
+                guard let _ = settings.identity.scopeAndName else {
+                    throw InternalError("invalid package identifier \(settings.identity)")
+                }
+
+                dependencyLocation = "\(settings.identity)"
             }
 
             // Otherwise, look it up by its identity.

Sources/PackageGraph/PackageModel+Extensions.swift

@@ -25,10 +25,10 @@ extension PackageDependency {
             case .remote(let url):
                 packageKind = .remoteSourceControl(url)
             }
-        case .registry:
-            // FIXME
-            fatalError("registry based dependencies not implemented yet")
+        case .registry(let settings):
+            packageKind = .registry(settings.identity)
         }
+
         return PackageReference(identity: self.identity, kind: packageKind)
     }
 }

Sources/PackageGraph/PinsStore.swift

@@ -250,6 +250,9 @@ fileprivate struct PinsStorage {
                 case .remoteSourceControl(let url):
                     kind = .remoteSourceControl
                     location = url.absoluteString
+                case .registry(let identity):
+                    kind = .registry
+                    location = "\(identity)" // FIXME:
                 default:
                     throw StringError("invalid package type \(pin.packageRef.kind)")
                 }
@@ -265,6 +268,7 @@ fileprivate struct PinsStorage {
         enum Kind: String, Codable {
             case localSourceControl
             case remoteSourceControl
+            case registry
         }
     }
 
@@ -317,10 +321,12 @@ extension PinsStore.Pin {
 
 extension PinsStore.Pin {
     fileprivate init(_ pin: PinsStorage.V2.Pin, mirrors: DependencyMirrors) throws {
-        let packageRef: PackageReference
         let identity = pin.identity
+
         // rdar://52529014, rdar://52529011: pin file should store the original location but remap when loading
         let location = mirrors.effectiveURL(for: pin.location)
+
+        let packageRef: PackageReference
         switch pin.kind {
         case .localSourceControl:
             packageRef = try .localSourceControl(identity: identity, path: AbsolutePath(validating: location))
@@ -329,7 +335,10 @@ extension PinsStore.Pin {
                 throw StringError("invalid url location: \(location)")
             }
             packageRef = .remoteSourceControl(identity: identity, url: url)
+        case .registry:
+            packageRef = .registry(identity: identity)
         }
+
         self.init(
             packageRef: packageRef,
             state: try .init(pin.state)

Sources/Workspace/Workspace.swift

@@ -2368,22 +2368,25 @@ extension Workspace {
 
         switch requirement {
         case .version(let version):
-            // FIXME: We need to get the revision here, and we don't have a
-            // way to get it back out of the resolver which is very
-            // annoying. Maybe we should make an SPI on the provider for
-            // this?
-            // FIXME: this should not block
-            // FIXME: this should be updated to support registry
-            guard let container = (try temp_await {
-                self.getContainer(for: package, skipUpdate: true, on: .sharedConcurrent, completion: $0)
-            }) as? SourceControlPackageContainer else {
-                throw InternalError("invalid container for \(package) expected a RepositoryPackageContainer")
-            }
-            guard let tag = container.getTag(for: version) else {
-                throw InternalError("unable to get tag for \(package) \(version); available versions \(try container.versionsDescending())")
+            if let _ = package.identity.scopeAndName {
+                checkoutState = .version(version, revision: .init(identifier: "\(version)"))
+            } else {
+                // FIXME: We need to get the revision here, and we don't have a
+                // way to get it back out of the resolver which is very
+                // annoying. Maybe we should make an SPI on the provider for
+                // this?
+                // FIXME: this should not block
+                guard let container = (try temp_await {
+                    self.getContainer(for: package, skipUpdate: true, on: .sharedConcurrent, completion: $0)
+                }) as? SourceControlPackageContainer else {
+                    throw InternalError("invalid container for \(package) expected a SourceControlPackageContainer")
+                }
+                guard let tag = container.getTag(for: version) else {
+                    throw InternalError("unable to get tag for \(package) \(version); available versions \(try container.versionsDescending())")
+                }
+                let revision = try container.getRevision(forTag: tag)
+                checkoutState = .version(version, revision: revision)
             }
-            let revision = try container.getRevision(forTag: tag)
-            checkoutState = .version(version, revision: revision)
 
         case .revision(let revision, .none):
             checkoutState = .revision(revision)
@@ -2828,8 +2831,33 @@ extension Workspace: PackageContainerProvider {
                     completion(.failure(error))
                 }
             }
-        case .registry:
-            fatalError("registry dependencies are supported at this point")
+        case .registry(let identity):
+            do {
+                guard let registryManager = registryManager else {
+                    throw InternalError("registry manager not configured")
+                }
+
+                guard let _ = identity.scopeAndName else {
+                    throw InternalError("cannot get registry container for package \(identity)")
+                }
+
+                let container = RegistryPackageContainer(
+                    package: package,
+                    identityResolver: identityResolver,
+                    manager: registryManager,
+                    manifestLoader: manifestLoader,
+                    toolsVersionLoader: toolsVersionLoader,
+                    currentToolsVersion: currentToolsVersion
+                )
+
+                queue.async {
+                    completion(.success(container))
+                }
+            } catch {
+                queue.async {
+                    completion(.failure(error))
+                }
+            }
         }
     }
 
@@ -2846,7 +2874,11 @@ extension Workspace: PackageContainerProvider {
         case .localSourceControl, .remoteSourceControl:
             return try self.checkoutRepository(package: package, at: checkoutState)
         case .registry:
-            fatalError("registry dependencies are supported at this point")
+            guard case .version(let version, _) = checkoutState else {
+                fatalError("cannot download source archive for package \(package) with checkout state \(checkoutState)")
+            }
+
+            return try self.downloadSourceArchive(for: package, at: version)
         }
     }
 
@@ -2863,24 +2895,16 @@ extension Workspace: PackageContainerProvider {
         // a local package.
         //
         // Note that we don't actually remove a local package from disk.
-        switch dependency.state {
-        case .local:
+        if case .local = dependency.state {
             self.state.dependencies.remove(package.identity)
             try self.state.save()
             return
-        case .checkout, .edited:
-            break
-        case .downloaded:
-            break
         }
 
-        // Inform the delegate.
-        delegate?.removing(repository: dependency.packageRef.location)
-
         // Compute the dependency which we need to remove.
         let dependencyToRemove: ManagedDependency
 
-        if case .edited(let _basedOn, let unmanagedPath) = dependency.state, let basedOn = _basedOn {
+        if case .edited(let basedOn?, let unmanagedPath) = dependency.state {
             // Remove the underlying dependency for edited packages.
             dependencyToRemove = basedOn
             let updatedDependency = Workspace.ManagedDependency.edited(
@@ -2895,13 +2919,17 @@ extension Workspace: PackageContainerProvider {
             self.state.dependencies.remove(dependencyToRemove.packageRef.identity)
         }
 
+        delegate?.removing(repository: dependency.packageRef.location)
+
         switch package.kind {
-        case .root, .fileSystem:
-            fatalError("local dependencies are supported")
+        case .root(let path):
+            throw InternalError("root dependency \(dependencyToRemove) cannot be removed at \(path)")
+        case .fileSystem(let path):
+            throw InternalError("local dependency \(dependencyToRemove) cannot be removed at \(path)")
         case .localSourceControl, .remoteSourceControl:
             try self.removeRepository(dependency: dependencyToRemove)
         case .registry:
-            fatalError("registry dependencies are supported at this point")
+            try self.removeSourceArchive(for: dependencyToRemove)
         }
 
         // Save the state.
@@ -3026,6 +3054,52 @@ extension Workspace {
     }
 }
 
+// MARK: - Source archive management
+
+extension Workspace {
+    func downloadSourceArchive(
+        for package: PackageReference,
+        at version: Version
+    ) throws -> AbsolutePath {
+        guard let registryManager = registryManager else {
+            throw InternalError("registry manager not initialized")
+        }
+
+        let path = self.location.sourceArchivesSubdirectory(for: package, at: version)
+
+        if !localFileSystem.exists(path) {
+            _ = try temp_await {
+                registryManager.downloadSourceArchive(for: version,
+                                                      of: package,
+                                                      into: localFileSystem,
+                                                      at: path,
+                                                      on: .sharedConcurrent,
+                                                      completion: $0)
+            }
+        }
+
+        self.state.dependencies.add(.downloaded(packageRef: package, version: version))
+        try self.state.save()
+
+        return path
+    }
+
+    func removeSourceArchive(
+        for dependency: ManagedDependency
+    ) throws {
+        guard case .downloaded(let version) = dependency.state else {
+            throw InternalError("cannot remove source archive for \(dependency) with state \(dependency.state)")
+        }
+
+        let path = self.location.sourceArchivesSubdirectory(for: dependency.packageRef, at: version)
+
+        try localFileSystem.removeFileTree(path)
+
+        self.state.dependencies.remove(dependency.packageRef.identity)
+
+        try self.state.save()
+    }
+}
 
 // MARK: - Utility extensions