Rename FunctionTypeSyntax.arguments should be named FunctionTypeSyntax.parameters

Author: kimdv

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -183,8 +183,8 @@ public let TYPE_NODES: [Node] = [
         kind: .token(choices: [.token(tokenKind: "LeftParenToken")])
       ),
       Child(
-        name: "Arguments",
-        kind: .collection(kind: .tupleTypeElementList, collectionElementName: "Argument"),
+        name: "Parameters",
+        kind: .collection(kind: .tupleTypeElementList, collectionElementName: "Parameter"),
         isIndented: true
       ),
       Child(

Sources/SwiftBasicFormat/generated/BasicFormat+Extensions.swift

@@ -44,7 +44,7 @@ fileprivate extension AnyKeyPath {
       return true
     case \FunctionCallExprSyntax.argumentList:
       return true
-    case \FunctionTypeSyntax.arguments:
+    case \FunctionTypeSyntax.parameters:
       return true
     case \MemberDeclBlockSyntax.members:
       return true

Sources/SwiftParser/Types.swift

@@ -61,21 +61,21 @@ extension Parser {
       let unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax?
       let leftParen: RawTokenSyntax
       let unexpectedBetweenLeftParenAndElements: RawUnexpectedNodesSyntax?
-      let arguments: RawTupleTypeElementListSyntax
+      let parameters: RawTupleTypeElementListSyntax
       let unexpectedBetweenElementsAndRightParen: RawUnexpectedNodesSyntax?
       let rightParen: RawTokenSyntax
       if let input = base.as(RawTupleTypeSyntax.self) {
         unexpectedBeforeLeftParen = input.unexpectedBeforeLeftParen
         leftParen = input.leftParen
         unexpectedBetweenLeftParenAndElements = input.unexpectedBetweenLeftParenAndElements
-        arguments = input.elements
+        parameters = input.elements
         unexpectedBetweenElementsAndRightParen = input.unexpectedBetweenElementsAndRightParen
         rightParen = input.rightParen
       } else {
         unexpectedBeforeLeftParen = nil
         leftParen = RawTokenSyntax(missing: .leftParen, arena: self.arena)
         unexpectedBetweenLeftParenAndElements = nil
-        arguments = RawTupleTypeElementListSyntax(
+        parameters = RawTupleTypeElementListSyntax(
           elements: [
             RawTupleTypeElementSyntax(
               inOut: nil,
@@ -100,7 +100,7 @@ extension Parser {
           unexpectedBeforeLeftParen,
           leftParen: leftParen,
           unexpectedBetweenLeftParenAndElements,
-          arguments: arguments,
+          parameters: parameters,
           unexpectedBetweenElementsAndRightParen,
           rightParen: rightParen,
           effectSpecifiers: effectSpecifiers,

Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift

@@ -85,6 +85,60 @@ public extension EnumDeclSyntax {
   }
 }
 
+public extension FunctionTypeSyntax {
+  @available(*, deprecated, renamed: "unexpectedBetweenLeftParenAndParameters")
+  var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? { unexpectedBetweenLeftParenAndParameters }
+
+  @available(*, deprecated, renamed: "parameters")
+  var arguments: TupleTypeElementListSyntax { parameters }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenParametersAndRightParen")
+  var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? { unexpectedBetweenParametersAndRightParen }
+
+  /// Adds the provided `element` to the node's `arguments`
+  /// - param element: The new `Argument` to add to the node's
+  ///                  `arguments` collection.
+  /// - returns: A copy of the receiver with the provided `Argument`
+  ///            appended to its `arguments` collection.
+  @available(*, deprecated, renamed: "addParameter")
+  func addArgument(_ element: TupleTypeElementSyntax) -> FunctionTypeSyntax {
+    return self.addParameter(element)
+  }
+
+  @available(*, deprecated, message: "Use an initializer with a arguments")
+  init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil,
+    leftParen: TokenSyntax = .leftParenToken(),
+    _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil,
+    arguments: TupleTypeElementListSyntax,
+    _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil,
+    rightParen: TokenSyntax = .rightParenToken(),
+    _ unexpectedBetweenRightParenAndEffectSpecifiers: UnexpectedNodesSyntax? = nil,
+    effectSpecifiers: TypeEffectSpecifiersSyntax? = nil,
+    _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil,
+    output: ReturnClauseSyntax,
+    _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeLeftParen,
+      leftParen: leftParen,
+      unexpectedBetweenLeftParenAndArguments,
+      parameters: arguments,
+      unexpectedBetweenArgumentsAndRightParen,
+      rightParen: rightParen,
+      unexpectedBetweenRightParenAndEffectSpecifiers,
+      effectSpecifiers: effectSpecifiers,
+      unexpectedBetweenEffectSpecifiersAndOutput,
+      output: output,
+      unexpectedAfterOutput,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 public extension NamedOpaqueReturnTypeSyntax {
   @available(*, deprecated, renamed: "unexpectedBeforeGenericParameterClause")
   var unexpectedBeforeGenericParameters: UnexpectedNodesSyntax? { unexpectedBeforeGenericParameterClause }

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1493,12 +1493,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBeforeLeftParen"
   case \FunctionTypeSyntax.leftParen:
     return "leftParen"
-  case \FunctionTypeSyntax.unexpectedBetweenLeftParenAndArguments:
-    return "unexpectedBetweenLeftParenAndArguments"
-  case \FunctionTypeSyntax.arguments:
-    return "arguments"
-  case \FunctionTypeSyntax.unexpectedBetweenArgumentsAndRightParen:
-    return "unexpectedBetweenArgumentsAndRightParen"
+  case \FunctionTypeSyntax.unexpectedBetweenLeftParenAndParameters:
+    return "unexpectedBetweenLeftParenAndParameters"
+  case \FunctionTypeSyntax.parameters:
+    return "parameters"
+  case \FunctionTypeSyntax.unexpectedBetweenParametersAndRightParen:
+    return "unexpectedBetweenParametersAndRightParen"
   case \FunctionTypeSyntax.rightParen:
     return "rightParen"
   case \FunctionTypeSyntax.unexpectedBetweenRightParenAndEffectSpecifiers:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -9967,9 +9967,9 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol {
   public init(
       _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, 
       leftParen: RawTokenSyntax, 
-      _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil, 
-      arguments: RawTupleTypeElementListSyntax, 
-      _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenLeftParenAndParameters: RawUnexpectedNodesSyntax? = nil, 
+      parameters: RawTupleTypeElementListSyntax, 
+      _ unexpectedBetweenParametersAndRightParen: RawUnexpectedNodesSyntax? = nil, 
       rightParen: RawTokenSyntax, 
       _ unexpectedBetweenRightParenAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, 
       effectSpecifiers: RawTypeEffectSpecifiersSyntax?, 
@@ -9983,9 +9983,9 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol {
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeLeftParen?.raw
       layout[1] = leftParen.raw
-      layout[2] = unexpectedBetweenLeftParenAndArguments?.raw
-      layout[3] = arguments.raw
-      layout[4] = unexpectedBetweenArgumentsAndRightParen?.raw
+      layout[2] = unexpectedBetweenLeftParenAndParameters?.raw
+      layout[3] = parameters.raw
+      layout[4] = unexpectedBetweenParametersAndRightParen?.raw
       layout[5] = rightParen.raw
       layout[6] = unexpectedBetweenRightParenAndEffectSpecifiers?.raw
       layout[7] = effectSpecifiers?.raw
@@ -10004,15 +10004,15 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenLeftParenAndParameters: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var arguments: RawTupleTypeElementListSyntax {
+  public var parameters: RawTupleTypeElementListSyntax {
     layoutView.children[3].map(RawTupleTypeElementListSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenParametersAndRightParen: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift

@@ -825,9 +825,9 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
       leadingTrivia: Trivia? = nil,
       _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil,
       leftParen: TokenSyntax = .leftParenToken(),
-      _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil,
-      arguments: TupleTypeElementListSyntax,
-      _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenLeftParenAndParameters: UnexpectedNodesSyntax? = nil,
+      parameters: TupleTypeElementListSyntax,
+      _ unexpectedBetweenParametersAndRightParen: UnexpectedNodesSyntax? = nil,
       rightParen: TokenSyntax = .rightParenToken(),
       _ unexpectedBetweenRightParenAndEffectSpecifiers: UnexpectedNodesSyntax? = nil,
       effectSpecifiers: TypeEffectSpecifiersSyntax? = nil,
@@ -842,9 +842,9 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (
             unexpectedBeforeLeftParen, 
             leftParen, 
-            unexpectedBetweenLeftParenAndArguments, 
-            arguments, 
-            unexpectedBetweenArgumentsAndRightParen, 
+            unexpectedBetweenLeftParenAndParameters, 
+            parameters, 
+            unexpectedBetweenParametersAndRightParen, 
             rightParen, 
             unexpectedBetweenRightParenAndEffectSpecifiers, 
             effectSpecifiers, 
@@ -855,9 +855,9 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
       let layout: [RawSyntax?] = [
           unexpectedBeforeLeftParen?.raw, 
           leftParen.raw, 
-          unexpectedBetweenLeftParenAndArguments?.raw, 
-          arguments.raw, 
-          unexpectedBetweenArgumentsAndRightParen?.raw, 
+          unexpectedBetweenLeftParenAndParameters?.raw, 
+          parameters.raw, 
+          unexpectedBetweenParametersAndRightParen?.raw, 
           rightParen.raw, 
           unexpectedBetweenRightParenAndEffectSpecifiers?.raw, 
           effectSpecifiers?.raw, 
@@ -896,7 +896,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenLeftParenAndParameters: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -905,7 +905,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var arguments: TupleTypeElementListSyntax {
+  public var parameters: TupleTypeElementListSyntax {
     get {
       return TupleTypeElementListSyntax(data.child(at: 3, parent: Syntax(self))!)
     }
@@ -914,13 +914,13 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
 
-  /// Adds the provided `element` to the node's `arguments`
+  /// Adds the provided `element` to the node's `parameters`
   /// collection.
-  /// - param element: The new `Argument` to add to the node's
-  ///                  `arguments` collection.
-  /// - returns: A copy of the receiver with the provided `Argument`
-  ///            appended to its `arguments` collection.
-  public func addArgument(_ element: TupleTypeElementSyntax) -> FunctionTypeSyntax {
+  /// - param element: The new `Parameter` to add to the node's
+  ///                  `parameters` collection.
+  /// - returns: A copy of the receiver with the provided `Parameter`
+  ///            appended to its `parameters` collection.
+  public func addParameter(_ element: TupleTypeElementSyntax) -> FunctionTypeSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -933,7 +933,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     return FunctionTypeSyntax(newData)
   }
 
-  public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenParametersAndRightParen: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -1000,9 +1000,9 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     return .layout([
           \Self.unexpectedBeforeLeftParen, 
           \Self.leftParen, 
-          \Self.unexpectedBetweenLeftParenAndArguments, 
-          \Self.arguments, 
-          \Self.unexpectedBetweenArgumentsAndRightParen, 
+          \Self.unexpectedBetweenLeftParenAndParameters, 
+          \Self.parameters, 
+          \Self.unexpectedBetweenParametersAndRightParen, 
           \Self.rightParen, 
           \Self.unexpectedBetweenRightParenAndEffectSpecifiers, 
           \Self.effectSpecifiers,