Add downloaded constructor to ManagedDependency

Define helpers for paths to downloaded source archives

Author: mattt

Sources/Workspace/Diagnostics.swift

@@ -129,6 +129,10 @@ extension Diagnostic.Message {
         .warning("dependency '\(packageName)' was being edited but is missing; falling back to original checkout")
     }
 
+    static func downloadedDependencyMissing(packageName: String, version: Version) -> Diagnostic.Message {
+        .warning("dependency '\(packageName)' was downloaded from a registry but is missing; downloading again")
+    }
+
     static func checkedOutDependencyMissing(packageName: String) -> Diagnostic.Message {
         .warning("dependency '\(packageName)' is missing; cloning again")
     }

Sources/Workspace/ManagedDependency.swift

@@ -33,6 +33,8 @@ public struct ManagedDependency: Equatable {
         /// located at the path. In other words, this dependency is being used
         /// for top of the tree style development.
         case edited(basedOn: ManagedDependency, EditedState)
+
+        case downloaded(version: Version)
     }
 
     /// The package reference.
@@ -49,12 +51,14 @@ public struct ManagedDependency: Equatable {
 
     /// Returns true if the dependency is edited.
     public var isEdited: Bool {
-        switch state {
-        case .checkout, .local:
-            return false
-        case .edited:
-            return true
-        }
+        if case .edited = state { return true }
+        return false
+    }
+
+    /// Returns true if the dependency is downloaded.
+    public var isDownloaded: Bool {
+        if case .downloaded = state { return true }
+        return false
     }
 
     /// Create a dependency present locally on the filesystem.
@@ -74,6 +78,12 @@ public struct ManagedDependency: Equatable {
         return ManagedDependency(package: dependency.package, state: .edited(basedOn: dependency, state))
     }
 
+
+    /// Create a dependency downloaded from a registry.
+    public static func downloaded(package: PackageReference, version: Version) -> ManagedDependency {
+        return ManagedDependency(package: package, state: .downloaded(version: version))
+    }
+
     init(package: PackageReference, state: State) {
         self.package = package
         self.state = state

Sources/Workspace/Workspace.swift

@@ -989,6 +989,8 @@ extension Workspace {
             diagnostics.emit(error: "dependency '\(dependency.package.name)' already in edit mode")
         case .local:
             diagnostics.emit(error: "local dependency '\(dependency.package.name)' can't be edited")
+        case .downloaded:
+            diagnostics.emit(error: "dependency downloaded from registry '\(dependency.package.name)' can't be edited")
         }
         return nil
     }
@@ -1200,20 +1202,8 @@ fileprivate extension PinsStore {
     ///
     /// This method does nothing if the dependency is in edited state.
     func pin(_ dependency: ManagedDependency) {
-
-        // Get the checkout state.
-        let checkoutState: CheckoutState
-        switch dependency.state {
-        case .checkout(let state):
-            checkoutState = state
-        case .edited, .local:
-            return
-        }
-
-        self.pin(
-            packageRef: dependency.package,
-            state: checkoutState
-        )
+        guard case .checkout(let state) = dependency.state else { return }
+        self.pin(packageRef: dependency.package, state: state)
     }
 }
 
@@ -1325,10 +1315,10 @@ extension Workspace {
                     if checkout.isBranchOrRevisionBased {
                         result.insert(dependency.package)
                     }
-                case .edited:
-                    continue
                 case .local:
                     result.insert(dependency.package)
+                default:
+                    continue
                 }
             }
 
@@ -1403,7 +1393,7 @@ extension Workspace {
                         requirement: .unversioned,
                         products: productFilter)
                     allConstraints.append(constraint)
-                case .checkout, .local:
+                default:
                     break
                 }
                 allConstraints += try externalManifest.dependencyConstraints(productFilter: productFilter)
@@ -1417,20 +1407,11 @@ extension Workspace {
             var constraints = [PackageContainerConstraint]()
 
             for (_, managedDependency, productFilter) in dependencies {
-                switch managedDependency.state {
-                case .checkout, .local: continue
-                case .edited: break
-                }
-                // FIXME: We shouldn't need to construct a new package reference object here.
-                // We should get the correct one from managed dependency object.
-                let ref = PackageReference.local(
-                    identity: managedDependency.package.identity,
-                    path: workspace.path(to: managedDependency)
-                )
-                let constraint = PackageContainerConstraint(
-                    package: ref,
-                    requirement: .unversioned,
-                    products: productFilter)
+                guard case .edited = managedDependency.state else { continue }
+
+                let constraint = PackageContainerConstraint(package: managedDependency.package,
+                                                            requirement: .unversioned,
+                                                            products: productFilter)
                 constraints.append(constraint)
             }
             return constraints
@@ -1476,6 +1457,8 @@ extension Workspace {
             return path
         case .local:
             return AbsolutePath(dependency.package.location)
+        case .downloaded(version: let version):
+            return self.location.sourceArchiveDirectory(for: dependency.package, at: version)
         }
     }
 
@@ -1619,6 +1602,9 @@ extension Workspace {
             default:
                 version = .none
             }
+        case .downloaded(version: let downloadedVersion):
+            packageKind = .remote
+            version = downloadedVersion
         case .edited, .local:
             packageKind = .local
             version = .none
@@ -2077,15 +2063,13 @@ extension Workspace {
         // We require cloning if there is no checkout or if the checkout doesn't
         // match with the pin.
         let requiredPins = pinsStore.pins.filter{ pin in
-            guard let dependency = state.dependencies[pin.packageRef.identity] else {
-                return true
-            }
-            switch dependency.state {
-            case .checkout(let checkoutState):
-                return pin.state != checkoutState
-            case .edited, .local:
+            guard let dependency = state.dependencies[pin.packageRef.identity],
+                  case .checkout(let checkoutState) = dependency.state
+            else {
                 return true
             }
+
+            return pin.state != checkoutState
         }
 
         // Clone the required pins.
@@ -2334,8 +2318,8 @@ extension Workspace {
 
         for dependency in state.dependencies {
             switch dependency.state {
-            case .checkout: break
-            case .edited, .local: continue
+            case .checkout, .downloaded: break
+            default: continue
             }
 
             let identity = dependency.package.identity
@@ -2488,6 +2472,8 @@ extension Workspace {
                     case .checkout:
                         let newState = PackageStateChange.State(requirement: .unversioned, products: products)
                         packageStateChanges[packageRef.location] = (packageRef, .updated(newState))
+                    case .downloaded:
+                        throw InternalError("downloaded package must be versioned")
                     }
                 } else {
                     let newState = PackageStateChange.State(requirement: .unversioned, products: products)
@@ -2536,16 +2522,16 @@ extension Workspace {
                 }
 
             case .version(let version):
-                if let currentDependency = currentDependency {
-                    if case .checkout(let checkoutState) = currentDependency.state, case .version(version, _) = checkoutState {
-                        packageStateChanges[packageRef.location] = (packageRef, .unchanged)
-                    } else {
-                        let newState = PackageStateChange.State(requirement: .version(version), products: products)
-                        packageStateChanges[packageRef.location] = (packageRef, .updated(newState))
-                    }
-                } else {
+                switch currentDependency?.state {
+                case nil:
                     let newState = PackageStateChange.State(requirement: .version(version), products: products)
                     packageStateChanges[packageRef.location] = (packageRef, .added(newState))
+                case .checkout(.version(version, _))?,
+                     .downloaded(version)?:
+                    packageStateChanges[packageRef.location] = (packageRef, .unchanged)
+                default:
+                    let newState = PackageStateChange.State(requirement: .version(version), products: products)
+                    packageStateChanges[packageRef.location] = (packageRef, .updated(newState))
                 }
             }
         }
@@ -2634,6 +2620,10 @@ extension Workspace {
 
                     diagnostics.emit(.editedDependencyMissing(packageName: dependency.package.name))
 
+                case .downloaded(version: let version):
+                    _ = try temp_await { registryManager?.downloadSourceArchive(for: version, of: dependency.package, into: fileSystem, at: path(to: dependency), expectedChecksum: nil, on: .sharedConcurrent, completion: $0) }
+                    diagnostics.emit(.downloadedDependencyMissing(packageName: dependency.package.name, version: version))
+
                 case .local:
                     state.dependencies.remove(dependency)
                     try state.saveState()
@@ -2842,13 +2832,10 @@ extension Workspace {
         // 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 {
             state.dependencies.remove(dependency)
             try state.saveState()
             return
-        case .checkout, .edited:
-            break
         }
 
         // Inform the delegate.
@@ -2913,6 +2900,8 @@ extension Workspace {
                 result.append("edited")
             case .local?:
                 result.append("versioned")
+            case .downloaded?:
+                result.append("downloaded")
             case nil:
                 result.append("root")
             }

Sources/Workspace/WorkspaceConfiguration.swift

@@ -59,6 +59,17 @@ extension Workspace {
             self.workingDirectory.appending(component: "artifacts")
         }
 
+        /// Path to store the dependencies downloaded from a registry.
+        public var sourceArchivesDirectory: AbsolutePath {
+            self.workingDirectory.appending(component: "source-archives")
+        }
+
+        /// Returns the path to the repository checkout directory for a managed dependency.
+        public func sourceArchiveDirectory(for package: PackageReference, at version: Version) -> AbsolutePath {
+            self.sourceArchivesDirectory.appending(subpath(for: package))
+                                        .appending(component: version.description.lowercased())
+        }
+
         /// Path to the shared repositories cache.
         public var sharedRepositoriesCacheDirectory: AbsolutePath? {
             self.sharedCacheDirectory.map { $0.appending(component: "repositories") }

Sources/Workspace/WorkspaceState.swift

@@ -243,6 +243,8 @@ fileprivate struct WorkspaceStateStorage {
                     case .managed:
                         try nestedContainer.encodeNil(forKey: .path)
                     }
+                case .downloaded(version: let version):
+                    fatalError("Not implemented") // FIXME
                 }
             }