Update swift-format for renamed children in SwiftSyntax

Author: ahoppen

Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift

@@ -45,7 +45,7 @@ public final class AllPublicDeclarationsHaveDocumentation: SyntaxLintRule {
   }
 
   public override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseMissingDocComment(DeclSyntax(node), name: node.identifier.text, modifiers: node.modifiers)
+    diagnoseMissingDocComment(DeclSyntax(node), name: node.name.text, modifiers: node.modifiers)
     return .skipChildren
   }
 
@@ -56,17 +56,17 @@ public final class AllPublicDeclarationsHaveDocumentation: SyntaxLintRule {
   }
 
   public override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseMissingDocComment(DeclSyntax(node), name: node.identifier.text, modifiers: node.modifiers)
+    diagnoseMissingDocComment(DeclSyntax(node), name: node.name.text, modifiers: node.modifiers)
     return .skipChildren
   }
 
   public override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseMissingDocComment(DeclSyntax(node), name: node.identifier.text, modifiers: node.modifiers)
+    diagnoseMissingDocComment(DeclSyntax(node), name: node.name.text, modifiers: node.modifiers)
     return .skipChildren
   }
 
   public override func visit(_ node: TypealiasDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseMissingDocComment(DeclSyntax(node), name: node.identifier.text, modifiers: node.modifiers)
+    diagnoseMissingDocComment(DeclSyntax(node), name: node.name.text, modifiers: node.modifiers)
     return .skipChildren
   }
 

Sources/SwiftFormatRules/AllPublicDeclarationsHaveDocumentation.swift

@@ -67,14 +67,14 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
   }
 
   public override func visit(_ node: ClosureSignatureSyntax) -> SyntaxVisitorContinueKind {
-    if let input = node.input {
+    if let input = node.parameterClause {
       if let closureParamList = input.as(ClosureParamListSyntax.self) {
         for param in closureParamList {
           diagnoseLowerCamelCaseViolations(
             param.name, allowUnderscores: false, description: identifierDescription(for: node))
         }
       } else if let parameterClause = input.as(ClosureParameterClauseSyntax.self) {
-        for param in parameterClause.parameterList {
+        for param in parameterClause.parameters {
           diagnoseLowerCamelCaseViolations(
             param.firstName, allowUnderscores: false, description: identifierDescription(for: node))
           if let secondName = param.secondName {
@@ -83,7 +83,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
           }
         }
       } else if let parameterClause = input.as(EnumCaseParameterClauseSyntax.self) {
-        for param in parameterClause.parameterList {
+        for param in parameterClause.parameters {
           if let firstName = param.firstName {
             diagnoseLowerCamelCaseViolations(
               firstName, allowUnderscores: false, description: identifierDescription(for: node))
@@ -94,7 +94,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
           }
         }
       } else if let parameterClause = input.as(ParameterClauseSyntax.self) {
-        for param in parameterClause.parameterList {
+        for param in parameterClause.parameters {
           diagnoseLowerCamelCaseViolations(
             param.firstName, allowUnderscores: false, description: identifierDescription(for: node))
           if let secondName = param.secondName {
@@ -119,9 +119,9 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
     // underscores to separate phrases in very detailed test names.
     let allowUnderscores = testCaseFuncs.contains(node)
     diagnoseLowerCamelCaseViolations(
-      node.identifier, allowUnderscores: allowUnderscores,
+      node.name, allowUnderscores: allowUnderscores,
       description: identifierDescription(for: node))
-    for param in node.signature.input.parameterList {
+    for param in node.signature.parameterClause.parameters {
       // These identifiers aren't described using `identifierDescription(for:)` because no single
       // node can disambiguate the argument label from the parameter name.
       diagnoseLowerCamelCaseViolations(
@@ -136,7 +136,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
 
   public override func visit(_ node: EnumCaseElementSyntax) -> SyntaxVisitorContinueKind {
     diagnoseLowerCamelCaseViolations(
-      node.identifier, allowUnderscores: false, description: identifierDescription(for: node))
+      node.name, allowUnderscores: false, description: identifierDescription(for: node))
     return .skipChildren
   }
 
@@ -157,9 +157,9 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
       } else if let functionDecl = member.decl.as(FunctionDeclSyntax.self) {
         // Identify test methods using the same heuristics as XCTest: name starts with "test", has
         // no arguments, and returns a void type.
-        if functionDecl.identifier.text.starts(with: "test")
-          && functionDecl.signature.input.parameterList.isEmpty
-          && (functionDecl.signature.output.map(\.isVoid) ?? true)
+        if functionDecl.name.text.starts(with: "test")
+          && functionDecl.signature.parameterClause.parameters.isEmpty
+          && (functionDecl.signature.returnClause.map(\.isVoid) ?? true)
         {
           set.insert(functionDecl)
         }
@@ -189,9 +189,9 @@ fileprivate func identifierDescription<NodeType: SyntaxProtocol>(for node: NodeT
   case .enumCaseElement: return "enum case"
   case .functionDecl: return "function"
   case .optionalBindingCondition(let binding):
-    return binding.bindingKeyword.tokenKind == .keyword(.var) ? "variable" : "constant"
+    return binding.bindingSpecifier.tokenKind == .keyword(.var) ? "variable" : "constant"
   case .variableDecl(let variableDecl):
-    return variableDecl.bindingKeyword.tokenKind == .keyword(.var) ? "variable" : "constant"
+    return variableDecl.bindingSpecifier.tokenKind == .keyword(.var) ? "variable" : "constant"
   default:
     return "identifier"
   }
@@ -200,10 +200,10 @@ fileprivate func identifierDescription<NodeType: SyntaxProtocol>(for node: NodeT
 extension ReturnClauseSyntax {
   /// Whether this return clause specifies an explicit `Void` return type.
   fileprivate var isVoid: Bool {
-    if let returnTypeIdentifier = returnType.as(SimpleTypeIdentifierSyntax.self) {
+    if let returnTypeIdentifier = type.as(SimpleTypeIdentifierSyntax.self) {
       return returnTypeIdentifier.name.text == "Void"
     }
-    if let returnTypeTuple = returnType.as(TupleTypeSyntax.self) {
+    if let returnTypeTuple = type.as(TupleTypeSyntax.self) {
       return returnTypeTuple.elements.isEmpty
     }
     return false

Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift

@@ -24,12 +24,12 @@ public final class AmbiguousTrailingClosureOverload: SyntaxLintRule {
       let decl = decls[0]
       diagnose(
         .ambiguousTrailingClosureOverload(decl.fullDeclName),
-        on: decl.identifier,
+        on: decl.name,
         notes: decls.dropFirst().map { decl in
           Finding.Note(
             message: .otherAmbiguousOverloadHere(decl.fullDeclName),
             location: Finding.Location(
-              decl.identifier.startLocation(converter: self.context.sourceLocationConverter))
+              decl.name.startLocation(converter: self.context.sourceLocationConverter))
           )
         })
     }
@@ -39,13 +39,13 @@ public final class AmbiguousTrailingClosureOverload: SyntaxLintRule {
     var overloads = [String: [FunctionDeclSyntax]]()
     var staticOverloads = [String: [FunctionDeclSyntax]]()
     for fn in functions {
-      let params = fn.signature.input.parameterList
+      let params = fn.signature.parameterClause.parameters
       guard let firstParam = params.firstAndOnly else { continue }
       guard firstParam.type.is(FunctionTypeSyntax.self) else { continue }
       if let mods = fn.modifiers, mods.has(modifier: "static") || mods.has(modifier: "class") {
-        staticOverloads[fn.identifier.text, default: []].append(fn)
+        staticOverloads[fn.name.text, default: []].append(fn)
       } else {
-        overloads[fn.identifier.text, default: []].append(fn)
+        overloads[fn.name.text, default: []].append(fn)
       }
     }
 

Sources/SwiftFormatRules/AmbiguousTrailingClosureOverload.swift

@@ -23,22 +23,22 @@ import SwiftSyntax
 public final class DontRepeatTypeInStaticProperties: SyntaxLintRule {
 
   public override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.identifier.text)
+    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.name.text)
     return .skipChildren
   }
 
   public override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.identifier.text)
+    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.name.text)
     return .skipChildren
   }
 
   public override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.identifier.text)
+    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.name.text)
     return .skipChildren
   }
 
   public override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.identifier.text)
+    diagnoseStaticMembers(node.memberBlock.members, endingWith: node.name.text)
     return .skipChildren
   }
 

Sources/SwiftFormatRules/DontRepeatTypeInStaticProperties.swift

@@ -31,7 +31,7 @@ public final class FullyIndirectEnum: SyntaxFormatRule {
       return DeclSyntax(node)
     }
 
-    diagnose(.moveIndirectKeywordToEnumDecl(name: node.identifier.text), on: node.identifier)
+    diagnose(.moveIndirectKeywordToEnumDecl(name: node.name.text), on: node.name)
 
     // Removes 'indirect' keyword from cases, reformats
     let newMembers = enumMembers.map {

Sources/SwiftFormatRules/FullyIndirectEnum.swift

@@ -15,9 +15,9 @@ import SwiftSyntax
 extension FunctionDeclSyntax {
   /// Constructs a name for a function that includes parameter labels, i.e. `foo(_:bar:)`.
   var fullDeclName: String {
-    let params = signature.input.parameterList.map { param in
+    let params = signature.parameterClause.parameters.map { param in
       "\(param.firstName.text):"
     }
-    return "\(identifier.text)(\(params.joined()))"
+    return "\(name.text)(\(params.joined()))"
   }
 }

Sources/SwiftFormatRules/FunctionDeclSyntax+Convenience.swift

@@ -41,7 +41,7 @@ public final class NeverForceUnwrap: SyntaxLintRule {
     guard context.importsXCTest == .doesNotImportXCTest else { return .skipChildren }
     guard let questionOrExclamation = node.questionOrExclamationMark else { return .skipChildren }
     guard questionOrExclamation.tokenKind == .exclamationMark else { return .skipChildren }
-    diagnose(.doNotForceCast(name: node.typeName.with(\.leadingTrivia, []).with(\.trailingTrivia, []).description), on: node)
+    diagnose(.doNotForceCast(name: node.type.with(\.leadingTrivia, []).with(\.trailingTrivia, []).description), on: node)
     return .skipChildren
   }
 }

Sources/SwiftFormatRules/NeverForceUnwrap.swift

@@ -22,10 +22,10 @@ import SwiftSyntax
 public final class NoEmptyTrailingClosureParentheses: SyntaxFormatRule {
 
   public override func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax {
-    guard node.argumentList.count == 0 else { return super.visit(node) }
+    guard node.arguments.count == 0 else { return super.visit(node) }
 
     guard let trailingClosure = node.trailingClosure,
-      node.argumentList.isEmpty && node.leftParen != nil else
+      node.arguments.isEmpty && node.leftParen != nil else
     {
       return super.visit(node)
     }

Sources/SwiftFormatRules/NoEmptyTrailingClosureParentheses.swift

@@ -37,7 +37,7 @@ public final class NoLabelsInCasePatterns: SyntaxFormatRule {
 
       // Search function call argument list for violations
       var newArgs: [TupleExprElementSyntax] = []
-      for argument in funcCall.argumentList {
+      for argument in funcCall.arguments {
         guard let label = argument.label else {
           newArgs.append(argument)
           continue
@@ -50,7 +50,7 @@ public final class NoLabelsInCasePatterns: SyntaxFormatRule {
         }
 
         // Remove label if it's the same as the value identifier
-        let name = valueBinding.valuePattern.with(\.leadingTrivia, []).with(\.trailingTrivia, []).description
+        let name = valueBinding.pattern.with(\.leadingTrivia, []).with(\.trailingTrivia, []).description
         guard name == label.text else {
           newArgs.append(argument)
           continue
@@ -60,7 +60,7 @@ public final class NoLabelsInCasePatterns: SyntaxFormatRule {
       }
 
       let newArgList = TupleExprElementListSyntax(newArgs)
-      let newFuncCall = funcCall.with(\.argumentList, newArgList)
+      let newFuncCall = funcCall.with(\.arguments, newArgList)
       let newExpPat = expPat.with(\.expression, ExprSyntax(newFuncCall))
       let newItem = item.with(\.pattern, PatternSyntax(newExpPat))
       newCaseItems.append(newItem)

Sources/SwiftFormatRules/NoLabelsInCasePatterns.swift

@@ -32,27 +32,27 @@ public final class NoLeadingUnderscores: SyntaxLintRule {
   public override class var isOptIn: Bool { return true }
 
   public override func visit(_ node: AssociatedtypeDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: EnumCaseElementSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
@@ -93,22 +93,22 @@ public final class NoLeadingUnderscores: SyntaxLintRule {
   }
 
   public override func visit(_ node: PrecedenceGroupDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 
   public override func visit(_ node: TypealiasDeclSyntax) -> SyntaxVisitorContinueKind {
-    diagnoseIfNameStartsWithUnderscore(node.identifier)
+    diagnoseIfNameStartsWithUnderscore(node.name)
     return .visitChildren
   }
 

Sources/SwiftFormatRules/NoLeadingUnderscores.swift

@@ -24,13 +24,13 @@ public final class NoVoidReturnOnFunctionSignature: SyntaxFormatRule {
   /// it for closure signatures, because that may introduce an ambiguity when closure signatures
   /// are inferred.
   public override func visit(_ node: FunctionSignatureSyntax) -> FunctionSignatureSyntax {
-    if let ret = node.output?.returnType.as(SimpleTypeIdentifierSyntax.self), ret.name.text == "Void" {
+    if let ret = node.returnClause?.type.as(SimpleTypeIdentifierSyntax.self), ret.name.text == "Void" {
       diagnose(.removeRedundantReturn("Void"), on: ret)
-      return node.with(\.output, nil)
+      return node.with(\.returnClause, nil)
     }
-    if let tup = node.output?.returnType.as(TupleTypeSyntax.self), tup.elements.isEmpty {
+    if let tup = node.returnClause?.type.as(TupleTypeSyntax.self), tup.elements.isEmpty {
       diagnose(.removeRedundantReturn("()"), on: tup)
-      return node.with(\.output, nil)
+      return node.with(\.returnClause, nil)
     }
     return node
   }

Sources/SwiftFormatRules/NoVoidReturnOnFunctionSignature.swift

@@ -103,7 +103,7 @@ public final class OneCasePerLine: SyntaxFormatRule {
         if element.associatedValue != nil || element.rawValue != nil {
           // Once we reach one of these, we need to write out the ones we've collected so far, then
           // emit a separate case declaration with the associated/raw value element.
-          diagnose(.moveAssociatedOrRawValueCase(name: element.identifier.text), on: element)
+          diagnose(.moveAssociatedOrRawValueCase(name: element.name.text), on: element)
 
           if let caseDeclForCollectedElements = collector.makeCaseDeclAndReset() {
             newMembers.append(member.with(\.decl, DeclSyntax(caseDeclForCollectedElements)))

Sources/SwiftFormatRules/OneCasePerLine.swift

@@ -20,7 +20,7 @@ import SwiftSyntax
 public final class OnlyOneTrailingClosureArgument: SyntaxLintRule {
 
   public override func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
-    guard (node.argumentList.contains { $0.expression.is(ClosureExprSyntax.self) }) else {
+    guard (node.arguments.contains { $0.expression.is(ClosureExprSyntax.self) }) else {
       return .skipChildren
     }
     guard node.trailingClosure != nil else { return .skipChildren }

Sources/SwiftFormatRules/OnlyOneTrailingClosureArgument.swift

@@ -523,7 +523,7 @@ fileprivate class Line {
     {
       return .testableImport
     }
-    if importDecl.importKind != nil {
+    if importDecl.importKindSpecifier != nil {
       return .declImport
     }
     return .regularImport