Print reason for requiring resolution

This moves the existing code for printing a `WorkspaceResolveReason` and always appends it to the diagnostic for an out-of-date required resolved file.

Author: neonichu

Sources/Commands/SwiftTool.swift

@@ -148,56 +148,9 @@ private class ToolWorkspaceDelegate: WorkspaceDelegate {
         guard isVerbose else { return }
 
         queue.sync {
-            self.stdoutStream <<< "Running resolver because "
-
-            switch reason {
-            case .forced:
-                self.stdoutStream <<< "it was forced"
-            case .newPackages(let packages):
-                let dependencies = packages.lazy.map({ "'\($0.location)'" }).joined(separator: ", ")
-                self.stdoutStream <<< "the following dependencies were added: \(dependencies)"
-            case .packageRequirementChange(let package, let state, let requirement):
-                self.stdoutStream <<< "dependency '\(package.name)' was "
-
-                switch state {
-                case .checkout(let checkoutState)?:
-                    switch checkoutState.requirement {
-                    case .versionSet(.exact(let version)):
-                        self.stdoutStream <<< "resolved to '\(version)'"
-                    case .versionSet(_):
-                        // Impossible
-                        break
-                    case .revision(let revision):
-                        self.stdoutStream <<< "resolved to '\(revision)'"
-                    case .unversioned:
-                        self.stdoutStream <<< "unversioned"
-                    }
-                case .edited?:
-                    self.stdoutStream <<< "edited"
-                case .local?:
-                    self.stdoutStream <<< "versioned"
-                case nil:
-                    self.stdoutStream <<< "root"
-                }
-
-                self.stdoutStream <<< " but now has a "
-
-                switch requirement {
-                case .versionSet:
-                    self.stdoutStream <<< "different version-based"
-                case .revision:
-                    self.stdoutStream <<< "different revision-based"
-                case .unversioned:
-                    self.stdoutStream <<< "unversioned"
-                }
-
-                self.stdoutStream <<< " requirement."
-            default:
-                self.stdoutStream <<< " requirements have changed."
-            }
-
+            self.stdoutStream <<< Workspace.format(workspaceResolveReason: reason)
             self.stdoutStream <<< "\n"
-            stdoutStream.flush()
+            self.stdoutStream.flush()
         }
     }
 

Sources/Workspace/Workspace.swift

@@ -2033,11 +2033,13 @@ extension Workspace {
             pinsStore: pinsStore
         )
 
-        if precomputationResult.isRequired {
+        if case let .required(reason) = precomputationResult {
+            let reasonString = Self.format(workspaceResolveReason: reason)
+
             if !fileSystem.exists(self.location.resolvedVersionsFile) {
-                diagnostics.emit(error: "a resolved file is required when automatic dependency resolution is disabled and should be placed at \(self.location.resolvedVersionsFile.pathString)")
+                diagnostics.emit(error: "a resolved file is required when automatic dependency resolution is disabled and should be placed at \(self.location.resolvedVersionsFile.pathString). \(reasonString)")
             } else {
-                diagnostics.emit(error: "an out-of-date resolved file was detected at \(self.location.resolvedVersionsFile.pathString), which is not allowed when automatic dependency resolution is disabled; please make sure to update the file to reflect the changes in dependencies")
+                diagnostics.emit(error: "an out-of-date resolved file was detected at \(self.location.resolvedVersionsFile.pathString), which is not allowed when automatic dependency resolution is disabled; please make sure to update the file to reflect the changes in dependencies. \(reasonString)")
             }
         }
 
@@ -2814,6 +2816,59 @@ extension Workspace {
         // Save the state.
         try state.saveState()
     }
+
+    public static func format(workspaceResolveReason reason: WorkspaceResolveReason) -> String {
+        let stream = BufferedOutputByteStream()
+        stream <<< "Running resolver because "
+
+        switch reason {
+        case .forced:
+            stream <<< "it was forced"
+        case .newPackages(let packages):
+            let dependencies = packages.lazy.map({ "'\($0.location)'" }).joined(separator: ", ")
+            stream <<< "the following dependencies were added: \(dependencies)"
+        case .packageRequirementChange(let package, let state, let requirement):
+            stream <<< "dependency '\(package.name)' was "
+
+            switch state {
+            case .checkout(let checkoutState)?:
+                switch checkoutState.requirement {
+                case .versionSet(.exact(let version)):
+                    stream <<< "resolved to '\(version)'"
+                case .versionSet(_):
+                    // Impossible
+                    break
+                case .revision(let revision):
+                    stream <<< "resolved to '\(revision)'"
+                case .unversioned:
+                    stream <<< "unversioned"
+                }
+            case .edited?:
+                stream <<< "edited"
+            case .local?:
+                stream <<< "versioned"
+            case nil:
+                stream <<< "root"
+            }
+
+            stream <<< " but now has a "
+
+            switch requirement {
+            case .versionSet:
+                stream <<< "different version-based"
+            case .revision:
+                stream <<< "different revision-based"
+            case .unversioned:
+                stream <<< "unversioned"
+            }
+
+            stream <<< " requirement."
+        default:
+            stream <<< " requirements have changed."
+        }
+
+        return stream.bytes.description
+    }
 }
 
 /// A result which can be loaded.