[NFC] Split Workspace.swift into smaller files (#7006)

### Motivation:

`Workspace.swift` has grown to an unmanageable size: ~4k lines, close to
4200 before #7000 was merged. The `Workspace` type is the main API for
SourceKit-LSP interactions with SwiftPM. As we'd like to add more
cross-compilation functionality here (e.g. allowing SourceKit-LSP to
select a different Swift SDK), this API should be more navigable and
easier to work with. Since the amount of `public` functions on
`Workspace` is limited, we should keep them grouped in the main
`Workspace.swift` file, but the actual implementations can be moved to
separate files for easier subsequent refactoring and further changes.

### Modifications:

Split `Workspace.swift` into more files, with each file corresponding to
an implementation aspect of the `Workspace` API.

Also applied our formatting rules to the new files.

### Result:

`Workspace.swift` is now only 1384 lines long. When looking for a
specific `Workspace` functionality implementation, you can look it up in
separate files that correspond to a larger area grouping that
functionality.

Author: MaxDesiatov

Sources/Workspace/CMakeLists.txt

@@ -11,6 +11,7 @@ add_library(Workspace
   DefaultPluginScriptRunner.swift
   Diagnostics.swift
   InitPackage.swift
+  LoadableResult.swift
   ManagedArtifact.swift
   ManagedDependency.swift
   PackageContainer/FileSystemPackageContainer.swift
@@ -22,7 +23,15 @@ add_library(Workspace
   Workspace.swift
   Workspace+BinaryArtifacts.swift
   Workspace+Configuration.swift
+  Workspace+Delegation.swift
+  Workspace+Dependencies.swift
+  Workspace+Editing.swift
   Workspace+Manifests.swift
+  Workspace+PackageContainer.swift
+  Workspace+Pinning.swift
+  Workspace+Registry.swift
+  Workspace+Signing.swift
+  Workspace+SourceControl.swift
   Workspace+State.swift)
 target_link_libraries(Workspace PUBLIC
   TSCBasic

Sources/Workspace/LoadableResult.swift

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A result which can be loaded.
+///
+/// It is useful for objects that hold a state on disk and need to be
+/// loaded frequently.
+public final class LoadableResult<Value> {
+    /// The constructor closure for the value.
+    private let construct: () throws -> Value
+
+    /// Create a loadable result.
+    public init(_ construct: @escaping () throws -> Value) {
+        self.construct = construct
+    }
+
+    /// Load and return the result.
+    public func loadResult() -> Result<Value, Error> {
+        Result(catching: {
+            try self.construct()
+        })
+    }
+
+    /// Load and return the value.
+    public func load() throws -> Value {
+        try self.loadResult().get()
+    }
+}

Sources/Workspace/Workspace+BinaryArtifacts.swift

@@ -12,9 +12,9 @@
 
 import Basics
 import Foundation
+import PackageLoading
 import PackageModel
 import SPMBuildCore
-import PackageLoading
 
 import struct TSCBasic.ByteString
 import protocol TSCBasic.HashAlgorithm
@@ -696,7 +696,8 @@ extension Workspace.BinaryArtifactsManager {
                 _ = try decoder.decode(XCFrameworkMetadata.self, from: fileSystem.readFileContents(infoPlist))
                 return .xcframework
             } catch {
-                observabilityScope.emit(debug: "info.plist found in '\(path)' but failed to parse: \(error.interpolationDescription)")
+                observabilityScope
+                    .emit(debug: "info.plist found in '\(path)' but failed to parse: \(error.interpolationDescription)")
             }
         }
 
@@ -716,6 +717,156 @@ extension Workspace.BinaryArtifactsManager {
     }
 }
 
+extension Workspace {
+    func updateBinaryArtifacts(
+        manifests: DependencyManifests,
+        addedOrUpdatedPackages: [PackageReference],
+        observabilityScope: ObservabilityScope
+    ) throws {
+        let manifestArtifacts = try self.binaryArtifactsManager.parseArtifacts(
+            from: manifests,
+            observabilityScope: observabilityScope
+        )
+
+        var artifactsToRemove: [ManagedArtifact] = []
+        var artifactsToAdd: [ManagedArtifact] = []
+        var artifactsToDownload: [BinaryArtifactsManager.RemoteArtifact] = []
+        var artifactsToExtract: [ManagedArtifact] = []
+
+        for artifact in state.artifacts {
+            if !manifestArtifacts.local
+                .contains(where: { $0.packageRef == artifact.packageRef && $0.targetName == artifact.targetName }) &&
+                !manifestArtifacts.remote
+                .contains(where: { $0.packageRef == artifact.packageRef && $0.targetName == artifact.targetName })
+            {
+                artifactsToRemove.append(artifact)
+            }
+        }
+
+        for artifact in manifestArtifacts.local {
+            let existingArtifact = self.state.artifacts[
+                packageIdentity: artifact.packageRef.identity,
+                targetName: artifact.targetName
+            ]
+
+            if artifact.path.extension?.lowercased() == "zip" {
+                // If we already have an artifact that was extracted from an archive with the same checksum,
+                // we don't need to extract the artifact again.
+                if case .local(let existingChecksum) = existingArtifact?.source,
+                   try existingChecksum == (self.binaryArtifactsManager.checksum(forBinaryArtifactAt: artifact.path))
+                {
+                    continue
+                }
+
+                artifactsToExtract.append(artifact)
+            } else {
+                guard let _ = try BinaryArtifactsManager.deriveBinaryArtifact(
+                    fileSystem: self.fileSystem,
+                    path: artifact.path,
+                    observabilityScope: observabilityScope
+                ) else {
+                    observabilityScope.emit(.localArtifactNotFound(
+                        artifactPath: artifact.path,
+                        targetName: artifact.targetName
+                    ))
+                    continue
+                }
+                artifactsToAdd.append(artifact)
+            }
+
+            if let existingArtifact, isAtArtifactsDirectory(existingArtifact) {
+                // Remove the old extracted artifact, be it local archived or remote one.
+                artifactsToRemove.append(existingArtifact)
+            }
+        }
+
+        for artifact in manifestArtifacts.remote {
+            let existingArtifact = self.state.artifacts[
+                packageIdentity: artifact.packageRef.identity,
+                targetName: artifact.targetName
+            ]
+
+            if let existingArtifact {
+                if case .remote(let existingURL, let existingChecksum) = existingArtifact.source {
+                    // If we already have an artifact with the same checksum, we don't need to download it again.
+                    if artifact.checksum == existingChecksum {
+                        continue
+                    }
+
+                    let urlChanged = artifact.url != URL(string: existingURL)
+                    // If the checksum is different but the package wasn't updated, this is a security risk.
+                    if !urlChanged && !addedOrUpdatedPackages.contains(artifact.packageRef) {
+                        observabilityScope.emit(.artifactChecksumChanged(targetName: artifact.targetName))
+                        continue
+                    }
+                }
+
+                if isAtArtifactsDirectory(existingArtifact) {
+                    // Remove the old extracted artifact, be it local archived or remote one.
+                    artifactsToRemove.append(existingArtifact)
+                }
+            }
+
+            artifactsToDownload.append(artifact)
+        }
+
+        // Remove the artifacts and directories which are not needed anymore.
+        observabilityScope.trap {
+            for artifact in artifactsToRemove {
+                state.artifacts.remove(packageIdentity: artifact.packageRef.identity, targetName: artifact.targetName)
+
+                if isAtArtifactsDirectory(artifact) {
+                    try fileSystem.removeFileTree(artifact.path)
+                }
+            }
+
+            for directory in try fileSystem.getDirectoryContents(self.location.artifactsDirectory) {
+                let directoryPath = self.location.artifactsDirectory.appending(component: directory)
+                if try fileSystem.isDirectory(directoryPath) && fileSystem.getDirectoryContents(directoryPath).isEmpty {
+                    try fileSystem.removeFileTree(directoryPath)
+                }
+            }
+        }
+
+        guard !observabilityScope.errorsReported else {
+            throw Diagnostics.fatalError
+        }
+
+        // Download the artifacts
+        let downloadedArtifacts = try self.binaryArtifactsManager.download(
+            artifactsToDownload,
+            artifactsDirectory: self.location.artifactsDirectory,
+            observabilityScope: observabilityScope
+        )
+        artifactsToAdd.append(contentsOf: downloadedArtifacts)
+
+        // Extract the local archived artifacts
+        let extractedLocalArtifacts = try self.binaryArtifactsManager.extract(
+            artifactsToExtract,
+            artifactsDirectory: self.location.artifactsDirectory,
+            observabilityScope: observabilityScope
+        )
+        artifactsToAdd.append(contentsOf: extractedLocalArtifacts)
+
+        // Add the new artifacts
+        for artifact in artifactsToAdd {
+            self.state.artifacts.add(artifact)
+        }
+
+        guard !observabilityScope.errorsReported else {
+            throw Diagnostics.fatalError
+        }
+
+        observabilityScope.trap {
+            try self.state.save()
+        }
+
+        func isAtArtifactsDirectory(_ artifact: ManagedArtifact) -> Bool {
+            artifact.path.isDescendant(of: self.location.artifactsDirectory)
+        }
+    }
+}
+
 extension FileSystem {
     // helper to decide if an archive directory would benefit from stripping first level
     fileprivate func shouldStripFirstLevel(

Sources/Workspace/Workspace+Configuration.swift

@@ -179,14 +179,14 @@ extension Workspace {
         /// - Parameters:
         ///   - rootPath: Path to the root of the package, from which other locations can be derived.
         public init(forRootPackage rootPath: AbsolutePath, fileSystem: FileSystem) throws {
-            self.init(
+            try self.init(
                 scratchDirectory: DefaultLocations.scratchDirectory(forRootPackage: rootPath),
                 editsDirectory: DefaultLocations.editsDirectory(forRootPackage: rootPath),
                 resolvedVersionsFile: DefaultLocations.resolvedVersionsFile(forRootPackage: rootPath),
                 localConfigurationDirectory: DefaultLocations.configurationDirectory(forRootPackage: rootPath),
-                sharedConfigurationDirectory: try fileSystem.swiftPMConfigurationDirectory,
-                sharedSecurityDirectory: try fileSystem.swiftPMSecurityDirectory,
-                sharedCacheDirectory: try fileSystem.swiftPMCacheDirectory
+                sharedConfigurationDirectory: fileSystem.swiftPMConfigurationDirectory,
+                sharedSecurityDirectory: fileSystem.swiftPMSecurityDirectory,
+                sharedCacheDirectory: fileSystem.swiftPMCacheDirectory
             )
         }
     }
@@ -208,7 +208,7 @@ extension Workspace {
         }
 
         public static func resolvedVersionsFile(forRootPackage rootPath: AbsolutePath) -> AbsolutePath {
-            rootPath.appending(Self.resolvedFileName)
+            rootPath.appending(self.resolvedFileName)
         }
 
         public static func configurationDirectory(forRootPackage rootPath: AbsolutePath) -> AbsolutePath {
@@ -300,7 +300,7 @@ extension Workspace.Configuration {
                 guard fileSystem.exists(path) else {
                     throw StringError("Did not find netrc file at \(path).")
                 }
-                providers.append(try NetrcAuthorizationProvider(path: path, fileSystem: fileSystem))
+                try providers.append(NetrcAuthorizationProvider(path: path, fileSystem: fileSystem))
             case .user:
                 // user .netrc file (most typical)
                 let userHomePath = try fileSystem.homeDirectory.appending(".netrc")
@@ -360,7 +360,7 @@ extension Workspace.Configuration {
                 guard fileSystem.exists(path) else {
                     throw StringError("did not find netrc file at \(path)")
                 }
-                providers.append(try NetrcAuthorizationProvider(path: path, fileSystem: fileSystem))
+                try providers.append(NetrcAuthorizationProvider(path: path, fileSystem: fileSystem))
             case .user:
                 let userHomePath = try fileSystem.homeDirectory.appending(".netrc")
                 // Add user .netrc file unless we don't have access
@@ -523,7 +523,7 @@ extension Workspace.Configuration {
                 return try DependencyMirrors()
             }
             return try self.fileSystem.withLock(on: self.path.parentDirectory, type: .shared) {
-                return try DependencyMirrors(try Self.load(self.path, fileSystem: self.fileSystem))
+                try DependencyMirrors(Self.load(self.path, fileSystem: self.fileSystem))
             }
         }
 
@@ -534,7 +534,7 @@ extension Workspace.Configuration {
                 try self.fileSystem.createDirectory(self.path.parentDirectory, recursive: true)
             }
             return try self.fileSystem.withLock(on: self.path.parentDirectory, type: .exclusive) {
-                let mirrors = try DependencyMirrors(try Self.load(self.path, fileSystem: self.fileSystem))
+                let mirrors = try DependencyMirrors(Self.load(self.path, fileSystem: self.fileSystem))
                 var updatedMirrors = try DependencyMirrors(mirrors.mapping)
                 try handler(&updatedMirrors)
                 if updatedMirrors != mirrors {