adding attributes to parameters

Author: leogdion

Sources/SyntaxKit/Function.swift

@@ -110,11 +110,20 @@ public struct Function: CodeBlock {
       paramList = FunctionParameterListSyntax(
         parameters.enumerated().compactMap { index, param in
           guard !param.name.isEmpty, !param.type.isEmpty else { return nil }
+
+          // Build parameter attributes
+          let paramAttributes = buildAttributeList(from: param.attributes)
+
+          // Determine spacing for firstName based on whether attributes are present
+          let firstNameLeadingTrivia: Trivia = paramAttributes.isEmpty ? [] : .space
+
           var paramSyntax = FunctionParameterSyntax(
+            attributes: paramAttributes,
             firstName: param.isUnnamed
-              ? .wildcardToken(trailingTrivia: .space) : .identifier(param.name),
+              ? .wildcardToken(leadingTrivia: firstNameLeadingTrivia)
+              : .identifier(param.name, leadingTrivia: firstNameLeadingTrivia),
             secondName: param.isUnnamed ? .identifier(param.name) : nil,
-            colon: .colonToken(leadingTrivia: .space, trailingTrivia: .space),
+            colon: .colonToken(trailingTrivia: .space),
             type: IdentifierTypeSyntax(name: .identifier(param.type)),
             defaultValue: param.defaultValue.map {
               InitializerClauseSyntax(

Sources/SyntaxKit/Parameter.swift

@@ -37,7 +37,7 @@ public struct Parameter: CodeBlock {
   let type: String
   let defaultValue: String?
   let isUnnamed: Bool
-  private var attributes: [AttributeInfo] = []
+  internal var attributes: [AttributeInfo] = []
 
   /// Creates a parameter for a function or initializer.
   /// - Parameters:

Tests/SyntaxKitTests/AttributeTests.swift

@@ -164,4 +164,36 @@ import Testing
     #expect(generated.contains("17.0"))
     #expect(generated.contains("var bar"))
   }
+
+  @Test("Parameter with attribute generates correct syntax")
+  func testParameterWithAttribute() throws {
+    let function = Function("process") {
+      Parameter(name: "data", type: "Data")
+        .attribute("escaping")
+    } _: {
+      Variable(.let, name: "result", type: "String", equals: "processed")
+    }
+
+    let generated = function.syntax.description
+    #expect(generated.contains("@escaping"))
+    #expect(generated.contains("data: Data"))
+    #expect(generated.contains("func process"))
+  }
+
+  @Test("Parameter with attribute arguments generates correct syntax")
+  func testParameterWithAttributeArguments() throws {
+    let function = Function("validate") {
+      Parameter(name: "input", type: "String")
+        .attribute("available", arguments: ["iOS", "17.0"])
+    } _: {
+      Variable(.let, name: "result", type: "Bool", equals: "true")
+    }
+
+    let generated = function.syntax.description
+    #expect(generated.contains("@available"))
+    #expect(generated.contains("iOS"))
+    #expect(generated.contains("17.0"))
+    #expect(generated.contains("input: String"))
+    #expect(generated.contains("func validate"))
+  }
 }