From d81e9876e0744339bfcb3e094da919caa2f101c1 Mon Sep 17 00:00:00 2001 From: Alex Hoppen Date: Wed, 9 Aug 2023 13:56:42 -0700 Subject: [PATCH] Update for the fact that syntax collections are always non-optional in SwiftSyntax now --- .../TokenStreamCreator.swift | 32 +++---- .../AddModifierRewriter.swift | 92 +++++++++++-------- .../AlwaysUseLowerCamelCase.swift | 4 +- .../AmbiguousTrailingClosureOverload.swift | 2 +- .../DontRepeatTypeInStaticProperties.swift | 3 +- .../FileScopedDeclarationPrivacy.swift | 2 +- .../SwiftFormatRules/FullyIndirectEnum.swift | 20 ++-- ...NeverUseImplicitlyUnwrappedOptionals.swift | 8 +- .../NoAccessLevelOnExtensionDeclaration.swift | 8 +- Sources/SwiftFormatRules/OrderedImports.swift | 2 +- .../UseSingleLinePropertyGetter.swift | 1 - .../UseSynthesizedInitializer.swift | 12 +-- 12 files changed, 92 insertions(+), 94 deletions(-) diff --git a/Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift b/Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift index 0fe1209f2..c4f769c8f 100644 --- a/Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift +++ b/Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift @@ -274,7 +274,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { // Prioritize keeping " macro (" together. Also include the ")" if the // parameter list is empty. let firstTokenAfterAttributes = - node.modifiers?.firstToken(viewMode: .sourceAccurate) ?? node.macroKeyword + node.modifiers.firstToken(viewMode: .sourceAccurate) ?? node.macroKeyword before(firstTokenAfterAttributes, tokens: .open) after(node.macroKeyword, tokens: .break) if hasArguments || node.genericParameterClause != nil { @@ -352,7 +352,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { // Prioritize keeping " func (" together. Also include the ")" if the parameter // list is empty. - let firstTokenAfterAttributes = node.modifiers?.firstToken(viewMode: .sourceAccurate) ?? node.funcKeyword + let firstTokenAfterAttributes = node.modifiers.firstToken(viewMode: .sourceAccurate) ?? node.funcKeyword before(firstTokenAfterAttributes, tokens: .open) after(node.funcKeyword, tokens: .break) if hasArguments || node.genericParameterClause != nil { @@ -392,7 +392,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { arrangeParameterClause(node.signature.parameterClause, forcesBreakBeforeRightParen: node.body != nil) // Prioritize keeping " init" together. - let firstTokenAfterAttributes = node.modifiers?.firstToken(viewMode: .sourceAccurate) ?? node.initKeyword + let firstTokenAfterAttributes = node.modifiers.firstToken(viewMode: .sourceAccurate) ?? node.initKeyword before(firstTokenAfterAttributes, tokens: .open) if hasArguments || node.genericParameterClause != nil { @@ -427,7 +427,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { before(node.firstToken(viewMode: .sourceAccurate), tokens: .open) // Prioritize keeping " subscript" together. - if let firstModifierToken = node.modifiers?.firstToken(viewMode: .sourceAccurate) { + if let firstModifierToken = node.modifiers.firstToken(viewMode: .sourceAccurate) { before(firstModifierToken, tokens: .open) if hasArguments || node.genericParameterClause != nil { @@ -700,18 +700,16 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { ? Token.break(.same, newlines: .soft) : Token.space before(node.catchKeyword, tokens: catchPrecedingBreak) - if let catchItems = node.catchItems { - // If there are multiple items in the `catch` clause, wrap each in open/close breaks so that - // their internal breaks stack correctly. Otherwise, if there is only a single clause, use the - // old (pre-SE-0276) behavior (a fixed space after the `catch` keyword). - if catchItems.count > 1 { - for catchItem in catchItems { - before(catchItem.firstToken(viewMode: .sourceAccurate), tokens: .break(.open(kind: .continuation))) - after(catchItem.lastToken(viewMode: .sourceAccurate), tokens: .break(.close(mustBreak: false), size: 0)) - } - } else { - before(node.catchItems?.firstToken(viewMode: .sourceAccurate), tokens: .space) + // If there are multiple items in the `catch` clause, wrap each in open/close breaks so that + // their internal breaks stack correctly. Otherwise, if there is only a single clause, use the + // old (pre-SE-0276) behavior (a fixed space after the `catch` keyword). + if node.catchItems.count > 1 { + for catchItem in node.catchItems { + before(catchItem.firstToken(viewMode: .sourceAccurate), tokens: .break(.open(kind: .continuation))) + after(catchItem.lastToken(viewMode: .sourceAccurate), tokens: .break(.close(mustBreak: false), size: 0)) } + } else { + before(node.catchItems.firstToken(viewMode: .sourceAccurate), tokens: .space) } arrangeBracesAndContents(of: node.body, contentsKeyPath: \.statements) @@ -1023,11 +1021,11 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor { preVisitInsertingContextualBreaks(node) // If there are multiple trailing closures, force all the closures in the call to break. - if let additionalTrailingClosures = node.additionalTrailingClosures { + if !node.additionalTrailingClosures.isEmpty { if let closure = node.trailingClosure { forcedBreakingClosures.insert(closure.id) } - for additionalTrailingClosure in additionalTrailingClosures { + for additionalTrailingClosure in node.additionalTrailingClosures { forcedBreakingClosures.insert(additionalTrailingClosure.closure.id) } } diff --git a/Sources/SwiftFormatRules/AddModifierRewriter.swift b/Sources/SwiftFormatRules/AddModifierRewriter.swift index 36ffc017e..a233a9f2b 100644 --- a/Sources/SwiftFormatRules/AddModifierRewriter.swift +++ b/Sources/SwiftFormatRules/AddModifierRewriter.swift @@ -23,124 +23,136 @@ fileprivate final class AddModifierRewriter: SyntaxRewriter { override func visit(_ node: VariableDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.bindingSpecifier) return DeclSyntax(result) } + var node = node + // If variable already has an accessor keyword, skip (do not overwrite) - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } // Put accessor keyword before the first modifier keyword in the declaration - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: FunctionDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.funcKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: AssociatedTypeDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.associatedtypeKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: ClassDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.classKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: EnumDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.enumKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: ProtocolDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.protocolKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: StructDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.structKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: TypeAliasDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.typealiasKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: InitializerDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.initKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } override func visit(_ node: SubscriptDeclSyntax) -> DeclSyntax { // Check for modifiers, and, if none, insert the modifier and relocate trivia from the displaced // token. - guard var modifiers = node.modifiers else { + guard !node.modifiers.isEmpty else { let result = setOnlyModifier(in: node, keywordKeypath: \.subscriptKeyword) return DeclSyntax(result) } - guard modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } - modifiers.triviaPreservingInsert(modifierKeyword, at: modifiers.startIndex) - return DeclSyntax(node.with(\.modifiers, modifiers)) + guard node.modifiers.accessLevelModifier == nil else { return DeclSyntax(node) } + var node = node + node.modifiers.triviaPreservingInsert(modifierKeyword, at: node.modifiers.startIndex) + return DeclSyntax(node) } /// Moves trivia in the given node to correct the placement of potentially displaced trivia in the diff --git a/Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift b/Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift index bfa6e7a8d..2baa29cbb 100644 --- a/Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift +++ b/Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift @@ -46,7 +46,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule { // Don't diagnose any issues when the variable is overriding, because this declaration can't // rename the variable. If the user analyzes the code where the variable is really declared, // then the diagnostic can be raised for just that location. - if let modifiers = node.modifiers, modifiers.has(modifier: "override") { + if node.modifiers.has(modifier: "override") { return .visitChildren } @@ -114,7 +114,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule { // Don't diagnose any issues when the function is overriding, because this declaration can't // rename the function. If the user analyzes the code where the function is really declared, // then the diagnostic can be raised for just that location. - if let modifiers = node.modifiers, modifiers.has(modifier: "override") { + if node.modifiers.has(modifier: "override") { return .visitChildren } diff --git a/Sources/SwiftFormatRules/AmbiguousTrailingClosureOverload.swift b/Sources/SwiftFormatRules/AmbiguousTrailingClosureOverload.swift index 809853223..4ba408259 100644 --- a/Sources/SwiftFormatRules/AmbiguousTrailingClosureOverload.swift +++ b/Sources/SwiftFormatRules/AmbiguousTrailingClosureOverload.swift @@ -42,7 +42,7 @@ public final class AmbiguousTrailingClosureOverload: SyntaxLintRule { 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") { + if fn.modifiers.has(modifier: "static") || fn.modifiers.has(modifier: "class") { staticOverloads[fn.name.text, default: []].append(fn) } else { overloads[fn.name.text, default: []].append(fn) diff --git a/Sources/SwiftFormatRules/DontRepeatTypeInStaticProperties.swift b/Sources/SwiftFormatRules/DontRepeatTypeInStaticProperties.swift index 3f2c68b7a..85eb7faeb 100644 --- a/Sources/SwiftFormatRules/DontRepeatTypeInStaticProperties.swift +++ b/Sources/SwiftFormatRules/DontRepeatTypeInStaticProperties.swift @@ -69,8 +69,7 @@ public final class DontRepeatTypeInStaticProperties: SyntaxLintRule { for member in members { guard let varDecl = member.decl.as(VariableDeclSyntax.self), - let modifiers = varDecl.modifiers, - modifiers.has(modifier: "static") || modifiers.has(modifier: "class") + varDecl.modifiers.has(modifier: "static") || varDecl.modifiers.has(modifier: "class") else { continue } let bareTypeName = removingPossibleNamespacePrefix(from: typeName) diff --git a/Sources/SwiftFormatRules/FileScopedDeclarationPrivacy.swift b/Sources/SwiftFormatRules/FileScopedDeclarationPrivacy.swift index 9050c6db9..aee84aa53 100644 --- a/Sources/SwiftFormatRules/FileScopedDeclarationPrivacy.swift +++ b/Sources/SwiftFormatRules/FileScopedDeclarationPrivacy.swift @@ -136,7 +136,7 @@ public final class FileScopedDeclarationPrivacy: SyntaxFormatRule { private func rewrittenDecl( _ decl: DeclType, modifiers: DeclModifierListSyntax?, - factory: (DeclModifierListSyntax?) -> DeclType + factory: (DeclModifierListSyntax) -> DeclType ) -> DeclType { let invalidAccess: TokenKind let validAccess: TokenKind diff --git a/Sources/SwiftFormatRules/FullyIndirectEnum.swift b/Sources/SwiftFormatRules/FullyIndirectEnum.swift index 1ae68067b..dc02ebde9 100644 --- a/Sources/SwiftFormatRules/FullyIndirectEnum.swift +++ b/Sources/SwiftFormatRules/FullyIndirectEnum.swift @@ -24,8 +24,7 @@ public final class FullyIndirectEnum: SyntaxFormatRule { public override func visit(_ node: EnumDeclSyntax) -> DeclSyntax { let enumMembers = node.memberBlock.members - guard let enumModifiers = node.modifiers, - !enumModifiers.has(modifier: "indirect"), + guard !node.modifiers.has(modifier: "indirect"), allCasesAreIndirect(in: enumMembers) else { return DeclSyntax(node) @@ -37,14 +36,13 @@ public final class FullyIndirectEnum: SyntaxFormatRule { let newMembers = enumMembers.map { (member: MemberBlockItemSyntax) -> MemberBlockItemSyntax in guard let caseMember = member.decl.as(EnumCaseDeclSyntax.self), - let modifiers = caseMember.modifiers, - modifiers.has(modifier: "indirect"), - let firstModifier = modifiers.first + caseMember.modifiers.has(modifier: "indirect"), + let firstModifier = caseMember.modifiers.first else { return member } - let newCase = caseMember.with(\.modifiers, modifiers.remove(name: "indirect")) + let newCase = caseMember.with(\.modifiers, caseMember.modifiers.remove(name: "indirect")) let formattedCase = rearrangeLeadingTrivia(firstModifier.leadingTrivia, on: newCase) return member.with(\.decl, DeclSyntax(formattedCase)) } @@ -70,7 +68,7 @@ public final class FullyIndirectEnum: SyntaxFormatRule { let newMemberBlock = node.memberBlock.with(\.members, MemberBlockItemListSyntax(newMembers)) return DeclSyntax( newEnumDecl - .with(\.modifiers, (newEnumDecl.modifiers ?? DeclModifierListSyntax([])) + [newModifier]) + .with(\.modifiers, newEnumDecl.modifiers + [newModifier]) .with(\.memberBlock, newMemberBlock)) } @@ -82,7 +80,7 @@ public final class FullyIndirectEnum: SyntaxFormatRule { for member in members { if let caseMember = member.decl.as(EnumCaseDeclSyntax.self) { hadCases = true - guard let modifiers = caseMember.modifiers, modifiers.has(modifier: "indirect") else { + guard caseMember.modifiers.has(modifier: "indirect") else { return false } } @@ -97,11 +95,11 @@ public final class FullyIndirectEnum: SyntaxFormatRule { ) -> EnumCaseDeclSyntax { var formattedCase = enumCaseDecl - if var modifiers = formattedCase.modifiers, var firstModifier = modifiers.first { + if var firstModifier = formattedCase.modifiers.first { // If the case has modifiers, attach the leading trivia to the first one. firstModifier.leadingTrivia = leadingTrivia - modifiers[modifiers.startIndex] = firstModifier - formattedCase.modifiers = modifiers + formattedCase.modifiers[formattedCase.modifiers.startIndex] = firstModifier + formattedCase.modifiers = formattedCase.modifiers } else { // Otherwise, attach the trivia to the `case` keyword itself. formattedCase.caseKeyword.leadingTrivia = leadingTrivia diff --git a/Sources/SwiftFormatRules/NeverUseImplicitlyUnwrappedOptionals.swift b/Sources/SwiftFormatRules/NeverUseImplicitlyUnwrappedOptionals.swift index d9e7a0cce..803f31c2a 100644 --- a/Sources/SwiftFormatRules/NeverUseImplicitlyUnwrappedOptionals.swift +++ b/Sources/SwiftFormatRules/NeverUseImplicitlyUnwrappedOptionals.swift @@ -40,11 +40,9 @@ public final class NeverUseImplicitlyUnwrappedOptionals: SyntaxLintRule { public override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { guard context.importsXCTest == .doesNotImportXCTest else { return .skipChildren } // Ignores IBOutlet variables - if let attributes = node.attributes { - for attribute in attributes { - if (attribute.as(AttributeSyntax.self))?.attributeName.as(IdentifierTypeSyntax.self)?.name.text == "IBOutlet" { - return .skipChildren - } + for attribute in node.attributes { + if (attribute.as(AttributeSyntax.self))?.attributeName.as(IdentifierTypeSyntax.self)?.name.text == "IBOutlet" { + return .skipChildren } } // Finds type annotation for variable(s) diff --git a/Sources/SwiftFormatRules/NoAccessLevelOnExtensionDeclaration.swift b/Sources/SwiftFormatRules/NoAccessLevelOnExtensionDeclaration.swift index 831af4b1e..d59a4bbc5 100644 --- a/Sources/SwiftFormatRules/NoAccessLevelOnExtensionDeclaration.swift +++ b/Sources/SwiftFormatRules/NoAccessLevelOnExtensionDeclaration.swift @@ -25,8 +25,8 @@ import SwiftSyntax public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule { public override func visit(_ node: ExtensionDeclSyntax) -> DeclSyntax { - guard let modifiers = node.modifiers, modifiers.count != 0 else { return DeclSyntax(node) } - guard let accessKeyword = modifiers.accessLevelModifier else { return DeclSyntax(node) } + guard !node.modifiers.isEmpty else { return DeclSyntax(node) } + guard let accessKeyword = node.modifiers.accessLevelModifier else { return DeclSyntax(node) } let keywordKind = accessKeyword.name.tokenKind switch keywordKind { @@ -51,7 +51,7 @@ public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule { var newKeyword = node.extensionKeyword newKeyword.leadingTrivia = accessKeyword.leadingTrivia let result = node.with(\.memberBlock, newMembers) - .with(\.modifiers, modifiers.remove(name: accessKeyword.name.text)) + .with(\.modifiers, node.modifiers.remove(name: accessKeyword.name.text)) .with(\.extensionKeyword, newKeyword) return DeclSyntax(result) @@ -62,7 +62,7 @@ public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule { on: accessKeyword) var newKeyword = node.extensionKeyword newKeyword.leadingTrivia = accessKeyword.leadingTrivia - let result = node.with(\.modifiers, modifiers.remove(name: accessKeyword.name.text)) + let result = node.with(\.modifiers, node.modifiers.remove(name: accessKeyword.name.text)) .with(\.extensionKeyword, newKeyword) return DeclSyntax(result) diff --git a/Sources/SwiftFormatRules/OrderedImports.swift b/Sources/SwiftFormatRules/OrderedImports.swift index aab84ae25..313af4e1e 100644 --- a/Sources/SwiftFormatRules/OrderedImports.swift +++ b/Sources/SwiftFormatRules/OrderedImports.swift @@ -514,7 +514,7 @@ fileprivate class Line { /// Returns a `LineType` the represents the type of import from the given import decl. private func importType(of importDecl: ImportDeclSyntax) -> LineType { - if let attr = importDecl.attributes?.firstToken(viewMode: .sourceAccurate), + if let attr = importDecl.attributes.firstToken(viewMode: .sourceAccurate), attr.tokenKind == .atSign, attr.nextToken(viewMode: .sourceAccurate)?.text == "testable" { diff --git a/Sources/SwiftFormatRules/UseSingleLinePropertyGetter.swift b/Sources/SwiftFormatRules/UseSingleLinePropertyGetter.swift index a40029627..ddc6dbd00 100644 --- a/Sources/SwiftFormatRules/UseSingleLinePropertyGetter.swift +++ b/Sources/SwiftFormatRules/UseSingleLinePropertyGetter.swift @@ -28,7 +28,6 @@ public final class UseSingleLinePropertyGetter: SyntaxFormatRule { let body = acc.body, accessors.count == 1, acc.accessorSpecifier.tokenKind == .keyword(.get), - acc.attributes == nil, acc.modifier == nil, acc.effectSpecifiers == nil else { return node } diff --git a/Sources/SwiftFormatRules/UseSynthesizedInitializer.swift b/Sources/SwiftFormatRules/UseSynthesizedInitializer.swift index 3f70f363e..d7bede3a1 100644 --- a/Sources/SwiftFormatRules/UseSynthesizedInitializer.swift +++ b/Sources/SwiftFormatRules/UseSynthesizedInitializer.swift @@ -31,11 +31,7 @@ public final class UseSynthesizedInitializer: SyntaxLintRule { let member = memberItem.decl // Collect all stored variables into a list if let varDecl = member.as(VariableDeclSyntax.self) { - guard let modifiers = varDecl.modifiers else { - storedProperties.append(varDecl) - continue - } - guard !modifiers.has(modifier: "static") else { continue } + guard !varDecl.modifiers.has(modifier: "static") else { continue } storedProperties.append(varDecl) // Collect any possible redundant initializers into a list } else if let initDecl = member.as(InitializerDeclSyntax.self) { @@ -208,13 +204,11 @@ fileprivate enum AccessLevel { fileprivate func synthesizedInitAccessLevel(using properties: [VariableDeclSyntax]) -> AccessLevel { var hasFileprivate = false for property in properties { - guard let modifiers = property.modifiers else { continue } - // Private takes precedence, so finding 1 private property defines the access level. - if modifiers.contains(where: {$0.name.tokenKind == .keyword(.private) && $0.detail == nil}) { + if property.modifiers.contains(where: {$0.name.tokenKind == .keyword(.private) && $0.detail == nil}) { return .private } - if modifiers.contains(where: {$0.name.tokenKind == .keyword(.fileprivate) && $0.detail == nil}) { + if property.modifiers.contains(where: {$0.name.tokenKind == .keyword(.fileprivate) && $0.detail == nil}) { hasFileprivate = true // Can't break here because a later property might be private. }