cleanup baseName and use concrete .text instead

Author: ktoso

Sources/SwiftSyntaxMacroExpansion/MacroReplacement.swift

@@ -18,7 +18,7 @@ enum MacroExpanderError: DiagnosticMessage {
   case undefined
   case definitionNotMacroExpansion
   case nonParameterReference(TokenSyntax)
-  case nonTypeReference(TypeSyntax)
+  case nonTypeReference(TokenSyntax)
   case nonLiteralOrParameter(ExprSyntax)
 
   var message: String {
@@ -187,13 +187,17 @@ fileprivate class ParameterReplacementVisitor: SyntaxAnyVisitor {
   }
 
   override func visit(_ node: GenericArgumentSyntax) -> SyntaxVisitorContinueKind {
-    let baseName = node.argument
+    guard let baseName = node.argument.as(IdentifierTypeSyntax.self)?.name else {
+      // Handle error
+      return .visitChildren
+    }
+
     guard let genericParameterClause = macro.genericParameterClause else {
       return .skipChildren
     }
 
-    let parameterIndex = genericParameterClause.parameters.firstIndex { (index, parameter) in
-      return parameter.name.text == "\(baseName)"
+    let matchedParameter = genericParameterClause.parameters.enumerated().first { (index, parameter) in
+      return parameter.name.text == baseName.text
     }
 
     guard let (parameterIndex, _) = matchedParameter else {

Tests/SwiftSyntaxMacroExpansionTest/MacroReplacementTests.swift

@@ -163,6 +163,54 @@ final class MacroReplacementTests: XCTestCase {
     )
   }
 
+  func testMacroGenericArgumentExpansion_ignoreTrivia() throws {
+    let macro: DeclSyntax =
+      """
+      macro gen<A, B /* some comment */>(a: A, b: B) = #otherMacro<A, B>(first: a, second: b)
+      """
+
+    let use: ExprSyntax =
+      """
+      #gen<Int, String>(a: 5, b: "Hello")
+      """
+
+    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
+    }
+
+    guard let replacementA = genericReplacements.first else {
+      XCTFail("Expected generic replacement for A")
+      return
+    }
+    guard let replacementB = genericReplacements.dropFirst().first else {
+      XCTFail("Expected generic replacement for B")
+      return
+    }
+    XCTAssertEqual(genericReplacements.count, 2)
+
+    XCTAssertEqual(replacementA.parameterIndex, 0)
+    XCTAssertEqual("\(replacementA.reference.argument)", "A")
+
+    XCTAssertEqual(replacementB.parameterIndex, 1)
+    XCTAssertEqual("\(replacementB.reference.argument)", "B")
+
+    let expandedSyntax = macroDecl.expand(
+      use.as(MacroExpansionExprSyntax.self)!,
+      definition: expansion,
+      replacements: replacements,
+      genericReplacements: genericReplacements
+    )
+    assertStringsEqualWithDiff(
+      expandedSyntax.description,
+      """
+      #otherMacro<A, B>(first: 5, second: "Hello")
+      """
+    )
+  }
+
   func testMacroGenericArgumentExpansion_notVisitGenericParameterArguments() throws {
     let macro: DeclSyntax =
       """