Make add-dependency idempotent

If a manifest already contains the exact dependency is being
added via a `add-dependency` call, don't add it twice. Instead, do
nothing. This ensures we don't end up with an invalid manifest with two
of the same dependencies in it.

If a manifest contains a dependency with the supplied URL but a
different version qualifier then throw an error explaining that the
supplied dependency has already been added.

Issue: #8519

Author: plemarquand

Sources/PackageModelSyntax/AddPackageDependency.swift

@@ -44,6 +44,13 @@ public enum AddPackageDependency {
             throw ManifestEditError.cannotFindPackage
         }
 
+        guard try checkExistingDependency(
+            dependency,
+            in: packageCall
+        ) else {
+            return PackageEditResult(manifestEdits: [])
+        }
+
         let newPackageCall = try addPackageDependencyLocal(
             dependency, to: packageCall
         )
@@ -55,6 +62,52 @@ public enum AddPackageDependency {
         )
     }
 
+    /// Check that the given package dependency doesn't already exist in the manifest.
+    /// If the exact same dependency already exists, `false` is returned to indicate
+    /// that no edits are needed. If a different dependency with the same id or url
+    /// with different arguments exists, an error is thrown.
+    private static func checkExistingDependency(
+        _ dependency: MappablePackageDependency.Kind,
+        in packageCall: FunctionCallExprSyntax
+    ) throws -> Bool {
+        let dependencySyntax = dependency.asSyntax()
+        guard let dependenctFnSyntax = dependencySyntax.as(FunctionCallExprSyntax.self) else {
+            throw ManifestEditError.cannotFindPackage // TODO: Fix error
+        }
+
+        guard let id = dependenctFnSyntax.arguments.first(where: {
+            $0.label?.text == "url" || $0.label?.text == "id" || $0.label?.text == "path"
+        }) else {
+            throw InternalError("Missing id or url argument in dependency syntax")
+        }
+
+        if let existingDependencies = packageCall.findArgument(labeled: "dependencies") {
+            // If we have an existing dependencies array, we need to check if
+            if let expr = existingDependencies.expression.as(ArrayExprSyntax.self) {
+                // Iterate through existing dependencies and look for an argument that matches
+                // either the `id` or `url` argument of the new dependency. 
+                let existingArgument = expr.elements.first { elem in
+                    if let funcExpr = elem.expression.as(FunctionCallExprSyntax.self) {
+                        return funcExpr.arguments.contains {
+                            $0.trimmedDescription == id.trimmedDescription
+                        }
+                    }
+                    return false
+                }
+
+                if let existingArgument {
+                    let normalizedExistingArgument = existingArgument.detached.with(\.trailingComma, nil)
+                    // This exact dependency already exists, return false to indicate we should do nothing.
+                    if normalizedExistingArgument.trimmedDescription == dependencySyntax.trimmedDescription {
+                        return false
+                    }
+                    throw ManifestEditError.existingDependency(dependencyName: dependency.identifier)
+                }
+            }
+        }
+        return true
+    }
+
     /// Implementation of adding a package dependency to an existing call.
     static func addPackageDependencyLocal(
         _ dependency: MappablePackageDependency.Kind,
@@ -67,3 +120,16 @@ public enum AddPackageDependency {
         )
     }
 }
+
+fileprivate extension MappablePackageDependency.Kind {
+    var identifier: String {
+        switch self {
+            case .sourceControl(let name, let path, _):
+                return name ?? path
+            case .fileSystem(let name, let location):
+                return name ?? location
+            case .registry(let id, _):
+                return id
+        }
+    }
+}

Sources/PackageModelSyntax/ManifestEditError.swift

@@ -22,6 +22,7 @@ package enum ManifestEditError: Error {
     case cannotFindTarget(targetName: String)
     case cannotFindArrayLiteralArgument(argumentName: String, node: Syntax)
     case oldManifest(ToolsVersion)
+    case existingDependency(dependencyName: String)
 }
 
 extension ToolsVersion {
@@ -43,6 +44,8 @@ extension ManifestEditError: CustomStringConvertible {
             "unable to find array literal for '\(name)' argument"
         case .oldManifest(let version):
             "package manifest version \(version) is too old: please update to manifest version \(ToolsVersion.minimumManifestEditVersion) or newer"
+        case .existingDependency(let name):
+            "unable to add dependency '\(name)' because it already exists in the list of dependencies"
         }
     }
 }