don't crash when keys are not unique in macro expansion

Author: ktoso

Diff for: Sources/SwiftSyntaxMacroExpansion/MacroReplacement.swift

@@ -363,19 +363,21 @@ extension MacroDeclSyntax {
     // FIXME: Do real call-argument matching between the argument list and the
     // macro parameter list, porting over from the compiler.
     let parameterReplacements = Dictionary(
-      uniqueKeysWithValues: replacements.map { replacement in
+      replacements.map { replacement in
         (replacement.reference, replacement.parameterIndex)
-      }
+      },
+      uniquingKeysWith: { l, r in l }
     )
     let arguments: [ExprSyntax] =
       argumentList?.map { element in
         element.expression
       } ?? []
 
     let genericReplacements = Dictionary(
-      uniqueKeysWithValues: genericReplacements.map { replacement in
+      genericReplacements.map { replacement in
         (replacement.reference, replacement.parameterIndex)
-      }
+      },
+      uniquingKeysWith: { l, r in l }
     )
     let genericArguments: [TypeSyntax] =
       genericArgumentList?.arguments.map { element in

Diff for: Tests/SwiftSyntaxMacroExpansionTest/MacroReplacementTests.swift

@@ -301,4 +301,43 @@ final class MacroReplacementTests: XCTestCase {
       """
     )
   }
+
+  func testMacroExpansion_dontCrashOnDuplicates() throws {
+    let macro: DeclSyntax =
+      """
+      macro gen(a: Array<Int>) = #other<A>(first: a)
+      """
+
+    let use: ExprSyntax =
+      """
+      #otheren<Int>(a: [1, 2, 3])
+      """
+
+    let macroDecl = macro.as(MacroDeclSyntax.self)!
+    let definition = try macroDecl.checkDefinition()
+    guard case let .expansion(expansion, replacements, genericReplacements) = definition else {
+      XCTFail("not a normal expansion")
+      return
+    }
+
+    var replacementsWithDupes = replacements
+    replacementsWithDupes.append(contentsOf: replacements)
+    var genericReplacementsWithDupes = genericReplacements
+    genericReplacementsWithDupes.append(contentsOf: genericReplacements)
+
+    XCTAssertEqual(genericReplacements.count, 0)
+
+    let expandedSyntax = macroDecl.expand(
+      use.as(MacroExpansionExprSyntax.self)!,
+      definition: expansion,
+      replacements: replacementsWithDupes,
+      genericReplacements: genericReplacementsWithDupes
+    )
+    assertStringsEqualWithDiff(
+      expandedSyntax.description,
+      """
+      #other<A>(first: [1, 2, 3])
+      """
+    )
+  }
 }