Some additional deprecation fixes missed by the other cherrypicks.

Author: allevato

Sources/SwiftFormat/PrettyPrint/TokenStreamCreator.swift

@@ -853,7 +853,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   override func visit(_ node: TupleExprSyntax) -> SyntaxVisitorContinueKind {
     // We'll do nothing if it's a zero-element tuple, because we just want to keep the empty `()`
     // together.
-    let elementCount = node.elementList.count
+    let elementCount = node.elements.count
 
     if elementCount == 1 {
       // A tuple with one element is a parenthesized expression; add a group around it to keep it
@@ -875,9 +875,9 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
       after(node.leftParen, tokens: .break(.open, size: 0), .open)
       before(node.rightParen, tokens: .break(.close, size: 0), .close)
 
-      insertTokens(.break(.same), betweenElementsOf: node.elementList)
+      insertTokens(.break(.same), betweenElementsOf: node.elements)
 
-      for element in node.elementList {
+      for element in node.elements {
         arrangeAsTupleExprElement(element)
       }
     }
@@ -2424,7 +2424,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
     return .visitChildren
   }
 
-  override func visit(_ node: AccessPathComponentSyntax) -> SyntaxVisitorContinueKind {
+  override func visit(_ node: ImportPathComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
 
@@ -3300,7 +3300,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   private func startsWithOpenDelimiter(_ node: Syntax) -> Bool {
     guard let token = node.firstToken(viewMode: .sourceAccurate) else { return false }
     switch token.tokenKind {
-    case .leftBrace, .leftParen, .leftSquareBracket: return true
+    case .leftBrace, .leftParen, .leftSquare: return true
     default: return false
     }
   }
@@ -3407,8 +3407,8 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
       return true
     case .tryExpr(let tryExpr):
       return isCompoundExpression(tryExpr.expression)
-    case .tupleExpr(let tupleExpr) where tupleExpr.elementList.count == 1:
-      return isCompoundExpression(tupleExpr.elementList.first!.expression)
+    case .tupleExpr(let tupleExpr) where tupleExpr.elements.count == 1:
+      return isCompoundExpression(tupleExpr.elements.first!.expression)
     default:
       return false
     }
@@ -3442,7 +3442,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   ///   not parenthesized.
   private func parenthesizedLeftmostExpr(of expr: ExprSyntax) -> TupleExprSyntax? {
     switch Syntax(expr).as(SyntaxEnum.self) {
-    case .tupleExpr(let tupleExpr) where tupleExpr.elementList.count == 1:
+    case .tupleExpr(let tupleExpr) where tupleExpr.elements.count == 1:
       return tupleExpr
     case .infixOperatorExpr(let infixOperatorExpr):
       return parenthesizedLeftmostExpr(of: infixOperatorExpr.leftOperand)
@@ -3604,7 +3604,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
         )
       }
 
-      if let innerExpr = parenthesizedExpr.elementList.first?.expression,
+      if let innerExpr = parenthesizedExpr.elements.first?.expression,
         let stringLiteralExpr = innerExpr.as(StringLiteralExprSyntax.self),
         stringLiteralExpr.openingQuote.tokenKind == .multilineStringQuote
       {

Sources/SwiftFormat/Rules/ReturnVoidInsteadOfEmptyTuple.swift

@@ -39,9 +39,9 @@ public final class ReturnVoidInsteadOfEmptyTuple: SyntaxFormatRule {
       return super.visit(node)
     }
 
-    // Make sure that function types nested in the argument list are also rewritten (for example,
+    // Make sure that function types nested in the parameter list are also rewritten (for example,
     // `(Int -> ()) -> ()` should become `(Int -> Void) -> Void`).
-    let arguments = visit(node.arguments)
+    let parameters = visit(node.parameters)
     let voidKeyword = makeVoidIdentifierType(toReplace: returnType)
     var rewrittenNode = node
     rewrittenNode.parameters = parameters

Sources/SwiftFormat/Rules/UseShorthandTypeNames.swift

@@ -154,8 +154,7 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
         valueType: typeArguments.1.argument,
         leftSquare: TokenSyntax.leftSquareToken(leadingTrivia: leadingTrivia),
         colon: TokenSyntax.colonToken(trailingTrivia: .spaces(1)),
-        rightSquareBracket:
-          TokenSyntax.rightSquareBracketToken(trailingTrivia: trailingTrivia))
+        rightSquare: TokenSyntax.rightSquareToken(trailingTrivia: trailingTrivia))
       newNode = ExprSyntax(dictTypeExpr)
 
     case "Optional":
@@ -267,18 +266,18 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
   /// have a valid expression representation.
   private func makeArrayTypeExpression(
     elementType: TypeSyntax,
-    leftSquareBracket: TokenSyntax,
-    rightSquareBracket: TokenSyntax
+    leftSquare: TokenSyntax,
+    rightSquare: TokenSyntax
   ) -> ArrayExprSyntax? {
     guard let elementTypeExpr = expressionRepresentation(of: elementType) else {
       return nil
     }
     return ArrayExprSyntax(
-      leftSquare: leftSquareBracket,
+      leftSquare: leftSquare,
       elements: ArrayElementListSyntax([
         ArrayElementSyntax(expression: elementTypeExpr, trailingComma: nil),
       ]),
-      rightSquare: rightSquareBracket)
+      rightSquare: rightSquare)
   }
 
   /// Returns a `DictionaryExprSyntax` whose single key/value pair is the expression representations
@@ -287,9 +286,9 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
   private func makeDictionaryTypeExpression(
     keyType: TypeSyntax,
     valueType: TypeSyntax,
-    leftSquareBracket: TokenSyntax,
+    leftSquare: TokenSyntax,
     colon: TokenSyntax,
-    rightSquareBracket: TokenSyntax
+    rightSquare: TokenSyntax
   ) -> DictionaryExprSyntax? {
     guard
       let keyTypeExpr = expressionRepresentation(of: keyType),
@@ -305,9 +304,9 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
         trailingComma: nil),
     ])
     return DictionaryExprSyntax(
-      leftSquare: leftSquareBracket,
+      leftSquare: leftSquare,
       content: .elements(dictElementList),
-      rightSquare: rightSquareBracket)
+      rightSquare: rightSquare)
   }
 
   /// Returns an `OptionalChainingExprSyntax` whose wrapped expression is the expression
@@ -417,7 +416,7 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
         valueType: dictionaryType.value,
         leftSquare: dictionaryType.leftSquare,
         colon: dictionaryType.colon,
-        rightSquareBracket: dictionaryType.rightSquareBracket)
+        rightSquare: dictionaryType.rightSquare)
       return ExprSyntax(result)
 
     case .optionalType(let optionalType):
@@ -430,7 +429,7 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
     case .functionType(let functionType):
       let result = makeFunctionTypeExpression(
         leftParen: functionType.leftParen,
-        argumentTypes: functionType.arguments,
+        parameters: functionType.parameters,
         rightParen: functionType.rightParen,
         effectSpecifiers: functionType.effectSpecifiers,
         arrow: functionType.returnClause.arrow,
@@ -442,7 +441,7 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
       guard let elementExprs = expressionRepresentation(of: tupleType.elements) else { return nil }
       let result = TupleExprSyntax(
         leftParen: tupleType.leftParen,
-        elementList: elementExprs,
+        elements: elementExprs,
         rightParen: tupleType.rightParen)
       return ExprSyntax(result)
 
@@ -474,22 +473,22 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
 
   private func makeFunctionTypeExpression(
     leftParen: TokenSyntax,
-    argumentTypes: TupleTypeElementListSyntax,
+    parameters: TupleTypeElementListSyntax,
     rightParen: TokenSyntax,
     effectSpecifiers: TypeEffectSpecifiersSyntax?,
     arrow: TokenSyntax,
     returnType: TypeSyntax
   ) -> SequenceExprSyntax? {
     guard
-      let argumentTypeExprs = expressionRepresentation(of: argumentTypes),
+      let parameterExprs = expressionRepresentation(of: parameters),
       let returnTypeExpr = expressionRepresentation(of: returnType)
     else {
       return nil
     }
 
     let tupleExpr = TupleExprSyntax(
       leftParen: leftParen,
-      elementList: argumentTypeExprs,
+      elements: parameterExprs,
       rightParen: rightParen)
     let arrowExpr = ArrowExprSyntax(
       effectSpecifiers: effectSpecifiers,