diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index aaab441..a473b18 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -6,11 +6,11 @@ on: jobs: publish: name: Publish - runs-on: macos-12 + runs-on: macos-13 strategy: matrix: xcode_version: - - "14.0.1" + - "15.0.1" env: DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode_version }}.app steps: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index f41ea08..ddb74a2 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -11,7 +11,7 @@ jobs: name: Test on Linux runs-on: ubuntu-22.04 container: - image: swift:5.7 + image: swift:5.9 steps: - uses: actions/checkout@v2 - name: Show Environments @@ -26,11 +26,11 @@ jobs: run: make test macOS: name: Test on macOS - runs-on: macos-12 + runs-on: macos-13 strategy: matrix: xcode_version: - - "14.0.1" + - "15.0.1" env: DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode_version }}.app steps: diff --git a/.swift-format.json b/.swift-format.json index 4eed3c9..c206655 100644 --- a/.swift-format.json +++ b/.swift-format.json @@ -12,21 +12,16 @@ "indentation": { "spaces": 4 }, - "blankLineBetweenMembers": { - "ignoreSingleLineProperties": true - }, "rules": { "AllPublicDeclarationsHaveDocumentation": false, "AlwaysUseLowerCamelCase": true, "AmbiguousTrailingClosureOverload": true, "BeginDocumentationCommentWithOneLineSummary": true, - "BlankLineBetweenMembers": true, "DoNotUseSemicolons": true, "DontRepeatTypeInStaticProperties": true, "FullyIndirectEnum": true, "GroupNumericLiterals": true, "IdentifiersMustBeASCII": true, - "MultiLineTrailingCommas": true, "NeverForceUnwrap": false, "NeverUseForceTry": false, "NeverUseImplicitlyUnwrappedOptionals": true, @@ -43,7 +38,6 @@ "OnlyOneTrailingClosureArgument": true, "OrderedImports": true, "ReturnVoidInsteadOfEmptyTuple": true, - "UseEnumForNamespacing": true, "UseLetInEveryBoundCaseVariable": false, "UseShorthandTypeNames": true, "UseSingleLinePropertyGetter": true, diff --git a/Makefile b/Makefile index 2585abf..c4319c6 100644 --- a/Makefile +++ b/Makefile @@ -4,13 +4,9 @@ SWIFT_BUILD_FLAGS := -c release --disable-sandbox TOOL_NAME := swift-mod XCODE_DEFAULT_TOOLCHAIN := /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain GITHUB_REPO := ra1028/$(TOOL_NAME) -DOCKER_IMAGE_NAME := swift:5.5 +DOCKER_IMAGE_NAME := swift:5.9 ifeq ($(shell uname), Darwin) -USE_SWIFT_STATIC_STDLIB := $(shell test -d $$(dirname $$(xcrun --find swift))/../lib/swift_static/macosx && echo use_swift_static_stdlib_flag) -ifeq ($(USE_SWIFT_STATIC_STDLIB), use_swift_static_stdlib_flag) -SWIFT_BUILD_FLAGS += -Xswiftc -static-stdlib -endif SWIFT_BUILD_FLAGS += --arch arm64 --arch x86_64 endif @@ -47,7 +43,7 @@ docker-test: zip: build install_name_tool -add_rpath @loader_path -add_rpath $(XCODE_DEFAULT_TOOLCHAIN)/usr/lib/swift/macosx $(TOOL_BIN) 2>/dev/null || true rm -f $(TOOL_NAME).zip - zip -j $(TOOL_NAME).zip $(TOOL_BIN) $(TOOL_BIN_DIR)/lib_InternalSwiftSyntaxParser.dylib LICENSE + zip -j $(TOOL_NAME).zip $(TOOL_BIN) LICENSE upload-zip: zip @[ -n "$(GITHUB_TOKEN)" ] || (echo "\nERROR: Make sure setting environment variable 'GITHUB_TOKEN'." && exit 1) diff --git a/Package.resolved b/Package.resolved index 29a8f39..8ab75bc 100644 --- a/Package.resolved +++ b/Package.resolved @@ -14,8 +14,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/apple/swift-syntax", "state" : { - "revision" : "04d4497be6b88e524a71778d828790e9589ae1c4", - "version" : "0.50700.0" + "revision" : "6ad4ea24b01559dde0773e3d091f1b9e36175036", + "version" : "509.0.2" } }, { diff --git a/Package.swift b/Package.swift index e36bd48..b2fdced 100644 --- a/Package.swift +++ b/Package.swift @@ -1,4 +1,4 @@ -// swift-tools-version:5.6 +// swift-tools-version:5.9 import PackageDescription @@ -14,8 +14,8 @@ let package = Package( ) ], dependencies: [ - .package(url: "https://github.com/apple/swift-syntax", .upToNextMinor(from: "0.50700.0")), .package(url: "https://github.com/apple/swift-argument-parser", .upToNextMinor(from: "1.1.2")), + .package(url: "https://github.com/apple/swift-syntax", .upToNextMinor(from: "509.0.1")), .package(url: "https://github.com/apple/swift-tools-support-core.git", from: "0.2.3"), .package(url: "https://github.com/jpsim/Yams.git", from: "5.0.0") ], @@ -46,7 +46,7 @@ let package = Package( .target( name: "SwiftModCore", dependencies: [ - .product(name: "SwiftSyntaxParser", package: "swift-syntax"), + .product(name: "SwiftParser", package: "swift-syntax"), .product(name: "SwiftToolsSupport-auto", package: "swift-tools-support-core"), "Yams", ] diff --git a/Sources/SwiftModCommands/Runners/RunCommandRunner.swift b/Sources/SwiftModCommands/Runners/RunCommandRunner.swift index 7db01c9..e0880f4 100644 --- a/Sources/SwiftModCommands/Runners/RunCommandRunner.swift +++ b/Sources/SwiftModCommands/Runners/RunCommandRunner.swift @@ -1,7 +1,7 @@ import Foundation import SwiftModCore +import SwiftParser import SwiftSyntax -import SwiftSyntaxParser import TSCBasic import Yams @@ -110,7 +110,7 @@ private extension RunCommandRunner { do { source = try self.fileSystem.readFileContents(path).cString - syntax = try Syntax(SyntaxParser.parse(source: source)) + syntax = Syntax(Parser.parse(source: source)) modifiedSyntax = pipeline.visit(syntax) } catch { diff --git a/Sources/SwiftModCore/Extensions/DeclModifierListSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/DeclModifierListSyntaxExtensions.swift new file mode 100644 index 0000000..8126c00 --- /dev/null +++ b/Sources/SwiftModCore/Extensions/DeclModifierListSyntaxExtensions.swift @@ -0,0 +1,27 @@ +import SwiftSyntax + +public extension DeclModifierListSyntax { + var hasFinal: Bool { + contains { $0.name.tokenKind == .keyword(.final) } + } + + var hasStatic: Bool { + contains { $0.name.tokenKind == .keyword(.static) } + } + + var accessLevelModifier: DeclModifierSyntax? { + first { modifier in + switch modifier.name.tokenKind { + case .keyword(.open), + .keyword(.public), + .keyword(.internal), + .keyword(.fileprivate), + .keyword(.private): + return true + + default: + return false + } + } + } +} diff --git a/Sources/SwiftModCore/Extensions/IdentifierPatternSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/IdentifierPatternSyntaxExtensions.swift index 0fa2626..4c28710 100644 --- a/Sources/SwiftModCore/Extensions/IdentifierPatternSyntaxExtensions.swift +++ b/Sources/SwiftModCore/Extensions/IdentifierPatternSyntaxExtensions.swift @@ -9,11 +9,11 @@ public extension IdentifierPatternSyntax { } private final class IdentifierBackticksRemover: SyntaxRewriter { - override func visit(_ token: TokenSyntax) -> Syntax { + override func visit(_ token: TokenSyntax) -> TokenSyntax { guard case .identifier(let text) = token.tokenKind else { - return Syntax(token) + return token } - return Syntax(token.withKind(.identifier(text.replacingOccurrences(of: "`", with: "")))) + return token.with(\.tokenKind, .identifier(text.replacingOccurrences(of: "`", with: ""))) } } diff --git a/Sources/SwiftModCore/Extensions/IndentExtensions.swift b/Sources/SwiftModCore/Extensions/IndentExtensions.swift index ad30bb6..bfc2508 100644 --- a/Sources/SwiftModCore/Extensions/IndentExtensions.swift +++ b/Sources/SwiftModCore/Extensions/IndentExtensions.swift @@ -7,7 +7,7 @@ public extension Indent { return .spaces(spaces) case .tab: - return .tabs(1) + return .tab } } } diff --git a/Sources/SwiftModCore/Extensions/ModifierListSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/ModifierListSyntaxExtensions.swift deleted file mode 100644 index 27ca0a1..0000000 --- a/Sources/SwiftModCore/Extensions/ModifierListSyntaxExtensions.swift +++ /dev/null @@ -1,27 +0,0 @@ -import SwiftSyntax - -public extension ModifierListSyntax { - var hasFinal: Bool { - contains { $0.name.tokenKind == .finalKeyward } - } - - var hasStatic: Bool { - contains { $0.name.tokenKind == .staticKeyword } - } - - var accessLevelModifier: DeclModifierSyntax? { - first { modifier in - switch modifier.name.tokenKind { - case .openKeyward, - .publicKeyword, - .internalKeyword, - .fileprivateKeyword, - .privateKeyword: - return true - - default: - return false - } - } - } -} diff --git a/Sources/SwiftModCore/Extensions/SyntaxFactoryExtensions.swift b/Sources/SwiftModCore/Extensions/SyntaxFactoryExtensions.swift deleted file mode 100644 index b1a14bf..0000000 --- a/Sources/SwiftModCore/Extensions/SyntaxFactoryExtensions.swift +++ /dev/null @@ -1,59 +0,0 @@ -import SwiftSyntax - -public extension SyntaxFactory { - static func makeOpenKeyward() -> TokenSyntax { - makeIdentifier(TokenKind.openKeywardText) - } - - static func makeDeclModifier(name: TokenSyntax) -> DeclModifierSyntax { - makeDeclModifier(name: name, detailLeftParen: nil, detail: nil, detailRightParen: nil) - } - - static func makeNilExpr() -> NilLiteralExprSyntax { - makeNilLiteralExpr(nilKeyword: SyntaxFactory.makeNilKeyword()) - } - - static func replacingTrivia( - _ node: S, - for token: TokenSyntax, - leading: Trivia? = nil, - trailing: Trivia? = nil - ) -> S { - TriviaReplacer(for: token, leading: leading, trailing: trailing) - .visit(Syntax(node)) - .as(S.self)! - } - - static func movingLeadingTrivia( - leading: L, - for leadingToken: TokenSyntax, - trailing: T, - for trailingToken: TokenSyntax - ) -> (leading: L, trailing: T) { - let leading = replacingTrivia(leading, for: leadingToken, leading: trailingToken.leadingTrivia) - let trailing = replacingTrivia(trailing, for: trailingToken, leading: []) - return (leading, trailing) - } -} - -private final class TriviaReplacer: SyntaxRewriter { - let token: TokenSyntax - let leading: Trivia - let trailing: Trivia - - init(for token: TokenSyntax, leading: Trivia?, trailing: Trivia?) { - self.token = token - self.leading = leading ?? token.leadingTrivia - self.trailing = trailing ?? token.trailingTrivia - } - - override func visit(_ token: TokenSyntax) -> Syntax { - guard token == self.token else { return Syntax(token) } - - return Syntax( - token - .withLeadingTrivia(leading) - .withTrailingTrivia(trailing) - ) - } -} diff --git a/Sources/SwiftModCore/Extensions/TokenKindExtensions.swift b/Sources/SwiftModCore/Extensions/TokenKindExtensions.swift index a8fa9e1..ffc0c0f 100644 --- a/Sources/SwiftModCore/Extensions/TokenKindExtensions.swift +++ b/Sources/SwiftModCore/Extensions/TokenKindExtensions.swift @@ -1,10 +1,6 @@ import SwiftSyntax public extension TokenKind { - static let openKeywardText = "open" - static let openKeyward = TokenKind.identifier(openKeywardText) - static let finalKeyward = TokenKind.identifier("final") - var isOptional: Bool { self == .identifier("Optional") } diff --git a/Sources/SwiftModCore/Extensions/TokenSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/TokenSyntaxExtensions.swift index c416820..e47efee 100644 --- a/Sources/SwiftModCore/Extensions/TokenSyntaxExtensions.swift +++ b/Sources/SwiftModCore/Extensions/TokenSyntaxExtensions.swift @@ -11,7 +11,7 @@ public extension TokenSyntax { func withLeadingTrivia(_ leadingTrivia: Trivia, condition: Bool) -> TokenSyntax { if condition { - return withLeadingTrivia(leadingTrivia) + return with(\.leadingTrivia, leadingTrivia) } else { return self @@ -20,10 +20,53 @@ public extension TokenSyntax { func withTrailingTrivia(_ trailingTrivia: Trivia, condition: Bool) -> TokenSyntax { if condition { - return withTrailingTrivia(trailingTrivia) + return with(\.trailingTrivia, trailingTrivia) } else { return self } } + + static func replacingTrivia( + _ node: S, + for token: TokenSyntax, + leading: Trivia? = nil, + trailing: Trivia? = nil + ) -> S { + TriviaReplacer(for: token, leading: leading, trailing: trailing) + .rewrite(Syntax(node)) + .as(S.self)! + } + + static func movingLeadingTrivia( + leading: L, + for leadingToken: TokenSyntax, + trailing: T, + for trailingToken: TokenSyntax + ) -> (leading: L, trailing: T) { + let leading = replacingTrivia(leading, for: leadingToken, leading: trailingToken.leadingTrivia) + let trailing = replacingTrivia(trailing, for: trailingToken, leading: []) + return (leading, trailing) + } +} + +private final class TriviaReplacer: SyntaxRewriter { + let token: TokenSyntax + let leading: Trivia + let trailing: Trivia + + init(for token: TokenSyntax, leading: Trivia?, trailing: Trivia?) { + self.token = token + self.leading = leading ?? token.leadingTrivia + self.trailing = trailing ?? token.trailingTrivia + } + + override func visit(_ token: TokenSyntax) -> TokenSyntax { + guard token == self.token else { return token } + + return + token + .with(\.leadingTrivia, leading) + .with(\.trailingTrivia, trailing) + } } diff --git a/Sources/SwiftModCore/Extensions/TypeSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/TypeSyntaxExtensions.swift index 2e0c40c..f80f12a 100644 --- a/Sources/SwiftModCore/Extensions/TypeSyntaxExtensions.swift +++ b/Sources/SwiftModCore/Extensions/TypeSyntaxExtensions.swift @@ -2,7 +2,7 @@ import SwiftSyntax public extension TypeSyntax { var isOptional: Bool { - if let identifier = self.as(SimpleTypeIdentifierSyntax.self), identifier.name.tokenKind.isOptional { + if let identifier = self.as(IdentifierTypeSyntax.self), identifier.name.tokenKind.isOptional { return true } else { diff --git a/Sources/SwiftModCore/Extensions/VariableDeclSyntaxExtensions.swift b/Sources/SwiftModCore/Extensions/VariableDeclSyntaxExtensions.swift index 0d0d679..f3a5627 100644 --- a/Sources/SwiftModCore/Extensions/VariableDeclSyntaxExtensions.swift +++ b/Sources/SwiftModCore/Extensions/VariableDeclSyntaxExtensions.swift @@ -20,6 +20,6 @@ public extension VariableDeclSyntax { } var hasAccessor: Bool { - bindings.contains { $0.accessor != nil } + bindings.contains { $0.accessorBlock != nil } } } diff --git a/Sources/SwiftModCore/Helpers/RulePipeline.swift b/Sources/SwiftModCore/Helpers/RulePipeline.swift index 0622c02..40ad1c6 100644 --- a/Sources/SwiftModCore/Helpers/RulePipeline.swift +++ b/Sources/SwiftModCore/Helpers/RulePipeline.swift @@ -9,7 +9,7 @@ public struct RulePipeline { public func visit(_ node: Syntax) -> Syntax { rules.reduce(node) { node, rule in - rule.rewriter().visit(node) + rule.rewriter().rewrite(node) } } } diff --git a/Sources/SwiftModCore/RuleSyntaxRewriter.swift b/Sources/SwiftModCore/RuleSyntaxRewriter.swift index 2f72490..537578f 100644 --- a/Sources/SwiftModCore/RuleSyntaxRewriter.swift +++ b/Sources/SwiftModCore/RuleSyntaxRewriter.swift @@ -24,9 +24,9 @@ open class RuleSyntaxRewriter: SyntaxRewriter, RuleSyntaxRewri public final override func visitAny(_ node: Syntax) -> Syntax? { // Whether to extract ignore options from comments - let shouldExtractNode = node.is(MemberDeclListItemSyntax.self) || node.is(CodeBlockItemSyntax.self) + let shouldExtractNode = node.is(MemberBlockItemSyntax.self) || node.is(CodeBlockItemSyntax.self) - guard shouldExtractNode, let leadingTrivia = node.firstToken?.leadingTrivia else { + guard shouldExtractNode, let leadingTrivia = node.firstToken(viewMode: .sourceAccurate)?.leadingTrivia else { return nil } diff --git a/Sources/SwiftModRules/DefaultAccessLevelRule.swift b/Sources/SwiftModRules/DefaultAccessLevelRule.swift index 1fd4be8..3098a7e 100644 --- a/Sources/SwiftModRules/DefaultAccessLevelRule.swift +++ b/Sources/SwiftModRules/DefaultAccessLevelRule.swift @@ -68,7 +68,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.structKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: super.visit ) } @@ -76,9 +76,19 @@ public final class DefaultAccessLevelRule: RuleDefinition { public override func visit(_ node: ClassDeclSyntax) -> DeclSyntax { visit( node, - getDeclKeyword: { $0.classOrActorKeyword }, + getDeclKeyword: { $0.classKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, + visitChildren: super.visit + ) + } + + public override func visit(_ node: ActorDeclSyntax) -> DeclSyntax { + visit( + node, + getDeclKeyword: { $0.actorKeyword }, + getModifiers: { $0.modifiers }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: super.visit ) } @@ -88,7 +98,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.enumKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: super.visit ) } @@ -98,27 +108,27 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.extensionKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: super.visit ) } - public override func visit(_ node: TypealiasDeclSyntax) -> DeclSyntax { + public override func visit(_ node: TypeAliasDeclSyntax) -> DeclSyntax { visit( node, getDeclKeyword: { $0.typealiasKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } - public override func visit(_ node: AssociatedtypeDeclSyntax) -> DeclSyntax { + public override func visit(_ node: AssociatedTypeDeclSyntax) -> DeclSyntax { visit( node, getDeclKeyword: { $0.associatedtypeKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -128,7 +138,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.protocolKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -136,9 +146,9 @@ public final class DefaultAccessLevelRule: RuleDefinition { public override func visit(_ node: VariableDeclSyntax) -> DeclSyntax { visit( node, - getDeclKeyword: { $0.letOrVarKeyword }, + getDeclKeyword: { $0.bindingSpecifier }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -148,7 +158,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.funcKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -158,7 +168,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.subscriptKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -168,7 +178,7 @@ public final class DefaultAccessLevelRule: RuleDefinition { node, getDeclKeyword: { $0.initKeyword }, getModifiers: { $0.modifiers }, - replacingModifiers: { $0.withModifiers($1) }, + replacingModifiers: { $0.with(\.modifiers, $1) }, visitChildren: nil ) } @@ -190,13 +200,13 @@ private extension DefaultAccessLevelRule.Rewriter { func visit( _ node: Node, getDeclKeyword: (Node) -> TokenSyntax, - getModifiers: (Node) -> ModifierListSyntax?, - replacingModifiers: (Node, ModifierListSyntax) -> Node, + getModifiers: (Node) -> DeclModifierListSyntax?, + replacingModifiers: (Node, DeclModifierListSyntax) -> Node, visitChildren: ((Node) -> DeclSyntax)? ) -> DeclSyntax { let implicitInternal = options.implicitInternal ?? true - let modifiers = getModifiers(node) ?? SyntaxFactory.makeModifierList([]) + let modifiers = getModifiers(node) ?? DeclModifierListSyntax([]) let visitFinally = visitChildren ?? DeclSyntax.init let parentVisit = visitStack.top @@ -232,24 +242,24 @@ private extension DefaultAccessLevelRule.Rewriter { let shouldOpen = canOpenInParent && !modifiers.hasFinal && !modifiers.hasStatic modifierTokenToAssign = shouldOpen - ? SyntaxFactory.makeOpenKeyward() - : SyntaxFactory.makePublicKeyword() + ? .keyword(.open) + : .keyword(.public) actualAccessLevel = shouldOpen ? .openOrPublic : .public case .public: - modifierTokenToAssign = SyntaxFactory.makePublicKeyword() + modifierTokenToAssign = .keyword(.public) actualAccessLevel = .public case .internal: - modifierTokenToAssign = implicitInternal ? nil : SyntaxFactory.makeInternalKeyword() + modifierTokenToAssign = implicitInternal ? nil : .keyword(.internal) actualAccessLevel = .internal case .fileprivate: - modifierTokenToAssign = SyntaxFactory.makeFileprivateKeyword() + modifierTokenToAssign = .keyword(.fileprivate) actualAccessLevel = .fileprivate case .private: - modifierTokenToAssign = SyntaxFactory.makePrivateKeyword() + modifierTokenToAssign = .keyword(.private) actualAccessLevel = .private } } @@ -268,32 +278,30 @@ private extension DefaultAccessLevelRule.Rewriter { ) let modifier = modifierTokenToAssign.map { token in - DeclModifierSyntax { builder in - builder.useName(token.withTrailingTrivia(.spaces(1))) - } + DeclModifierSyntax(name: token.with(\.trailingTrivia, .space)) } // If originally has modifiers. - if let modifier = modifier, let firstModifier = modifiers.first, let firstModifierToken = firstModifier.firstToken { + if let modifier = modifier, let firstModifier = modifiers.first, let firstModifierToken = firstModifier.firstToken(viewMode: .sourceAccurate) { // Prepends an access level modifier that exchanged the leading trivia. - let (leading, trailing) = SyntaxFactory.movingLeadingTrivia( + let (leading, trailing) = TokenSyntax.movingLeadingTrivia( leading: modifier, for: modifier.name, trailing: firstModifier, for: firstModifierToken ) - let newModifiers = SyntaxFactory.makeModifierList([leading, trailing] + Array(modifiers.dropFirst())) + let newModifiers = DeclModifierListSyntax([leading, trailing] + Array(modifiers.dropFirst())) return visitFinally(replacingModifiers(node, newModifiers)) } - else if let modifier = modifier, let nodeToken = getDeclKeyword(node).firstToken { + else if let modifier = modifier, let nodeToken = getDeclKeyword(node).firstToken(viewMode: .sourceAccurate) { // Assigns an access level modifier that exchanged the leading trivia. - let (newModifier, newNode) = SyntaxFactory.movingLeadingTrivia( + let (newModifier, newNode) = TokenSyntax.movingLeadingTrivia( leading: modifier, for: modifier.name, trailing: node, for: nodeToken ) - let newModifiers = SyntaxFactory.makeModifierList([newModifier]) + let newModifiers = DeclModifierListSyntax([newModifier]) return visitFinally(replacingModifiers(newNode, newModifiers)) } else { @@ -354,23 +362,23 @@ private extension DeclSyntaxProtocol { } } -private extension ModifierListSyntax { +private extension DeclModifierListSyntax { var accessLevel: DefaultAccessLevelRule.AccessLebel? { accessLevelModifier.flatMap { modifier in switch modifier.name.tokenKind { - case .openKeyward: + case .keyword(.open): return .openOrPublic - case .publicKeyword: + case .keyword(.public): return .public - case .internalKeyword: + case .keyword(.internal): return .internal - case .fileprivateKeyword: + case .keyword(.fileprivate): return .fileprivate - case .privateKeyword: + case .keyword(.private): return .private default: diff --git a/Sources/SwiftModRules/DefaultMemberwiseInitializerRule.swift b/Sources/SwiftModRules/DefaultMemberwiseInitializerRule.swift index f575473..ead62c8 100644 --- a/Sources/SwiftModRules/DefaultMemberwiseInitializerRule.swift +++ b/Sources/SwiftModRules/DefaultMemberwiseInitializerRule.swift @@ -68,8 +68,8 @@ public final class DefaultMemberwiseInitializerRule: RuleDefinition { visit( node, getModifiers: { $0.modifiers }, - getMembers: { $0.members }, - replacingMembers: { $0.withMembers($1) }, + getMembers: { $0.memberBlock }, + replacingMembers: { $0.with(\.memberBlock, $1) }, visitChildren: super.visit ) } @@ -78,8 +78,8 @@ public final class DefaultMemberwiseInitializerRule: RuleDefinition { visit( node, getModifiers: { $0.modifiers }, - getMembers: { $0.members }, - replacingMembers: { $0.withMembers($1) }, + getMembers: { $0.memberBlock }, + replacingMembers: { $0.with(\.memberBlock, $1) }, visitChildren: super.visit ) } @@ -95,9 +95,9 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { func visit( _ node: Node, - getModifiers: (Node) -> ModifierListSyntax?, - getMembers: (Node) -> MemberDeclBlockSyntax, - replacingMembers: (Node, MemberDeclBlockSyntax) -> Node, + getModifiers: (Node) -> DeclModifierListSyntax?, + getMembers: (Node) -> MemberBlockSyntax, + replacingMembers: (Node, MemberBlockSyntax) -> Node, visitChildren: (Node) -> DeclSyntax ) -> DeclSyntax { let implicitInternal = options.implicitInternal ?? true @@ -106,7 +106,7 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { let modifiers = getModifiers(node) let accessLevelModifier = modifiers?.accessLevelModifier? - .withoutTrivia() + .trimmed .assignableToInitializer let members = getMembers(node) let memberList = members.members @@ -116,15 +116,15 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { return nil } - let hasStatic = variableDecl.modifiers?.hasStatic ?? false + let hasStatic = variableDecl.modifiers.hasStatic let hasAccessor = variableDecl.hasAccessor let value = variableDecl.value // The variable that defined as `let` and already initialized once is not need a initializer parameter.. - let isAlreadyInitialized = variableDecl.letOrVarKeyword.isLet && value != nil + let isAlreadyInitialized = variableDecl.bindingSpecifier.isLet && value != nil guard !hasStatic && !hasAccessor && !isAlreadyInitialized, - let identifierPattern = variableDecl.identifier?.withoutTrivia(), - let type = variableDecl.typeAnnotation?.withoutTrivia().type.transformed() + let identifierPattern = variableDecl.identifier?.trimmed, + let type = variableDecl.typeAnnotation?.trimmed.type.transformed() else { return nil } @@ -132,7 +132,7 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { return StoredProperty( identifierPattern: identifierPattern, type: type, - value: value ?? (type.isOptional ? ExprSyntax(SyntaxFactory.makeNilExpr()) : nil) + value: value ?? (type.isOptional ? ExprSyntax(NilLiteralExprSyntax(nilKeyword: .keyword(.nil))) : nil) ) } @@ -146,141 +146,130 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { return visitChildren(node) } - let parentIndentTrivia = node.firstToken?.leadingTrivia.indentation ?? Trivia() + let parentIndentTrivia = node.firstToken(viewMode: .sourceAccurate)?.leadingTrivia.indentation ?? Trivia() let indentTrivia = parentIndentTrivia + format.indent.trivia let parameterIndentTrivia = indentTrivia + format.indent.trivia let shouldLineBreakParameters = format.lineBreakBeforeEachArgument && storedProperties.count > 1 // Make parameter clause. - let parameterClause = SyntaxFactory.makeParameterClause( - leftParen: SyntaxFactory.makeLeftParenToken(), - parameterList: SyntaxFactory.makeFunctionParameterList( + let parameterClause = FunctionParameterClauseSyntax( + leftParen: .leftParenToken(), + parameters: FunctionParameterListSyntax( storedProperties.indices.map { index in let property = storedProperties[index] let isLast = index == storedProperties.index(before: storedProperties.endIndex) - return SyntaxFactory.makeFunctionParameter( - attributes: nil, + return FunctionParameterSyntax( firstName: property.identifierPattern.identifier.withLeadingTrivia( - .newlines(1) + parameterIndentTrivia + property.identifierPattern.identifier.leadingTrivia, + .newline + parameterIndentTrivia + property.identifierPattern.identifier.leadingTrivia, condition: shouldLineBreakParameters ), - secondName: nil, - colon: SyntaxFactory.makeColonToken().withTrailingTrivia(.spaces(1)), + colon: .colonToken(trailingTrivia: .space), // Assings the attributes to type if needed. type: property.type.attributed(), - ellipsis: nil, - defaultArgument: property.value.map { value in - SyntaxFactory.makeInitializerClause( - equal: SyntaxFactory.makeEqualToken() - .withLeadingTrivia(.spaces(1)) - .withTrailingTrivia(.spaces(1)), + defaultValue: property.value.map { value in + InitializerClauseSyntax( + equal: .equalToken(leadingTrivia: .space, trailingTrivia: .space), value: value ) }, trailingComma: isLast ? nil - : SyntaxFactory - .makeCommaToken() - .withTrailingTrivia(.spaces(1), condition: !shouldLineBreakParameters) + : .commaToken().withTrailingTrivia(.space, condition: !shouldLineBreakParameters) ) } ), - rightParen: SyntaxFactory.makeRightParenToken().withLeadingTrivia(.newlines(1) + indentTrivia, condition: shouldLineBreakParameters) + rightParen: .rightParenToken() + .withLeadingTrivia(.newline + indentTrivia, condition: shouldLineBreakParameters) ) // Make initializer code block. - let initializerCodeBlock = SyntaxFactory.makeCodeBlock( - leftBrace: SyntaxFactory.makeLeftBraceToken() - .withLeadingTrivia(.spaces(1)) - .withTrailingTrivia(storedProperties.isEmpty ? [] : .newlines(1)), - statements: SyntaxFactory.makeCodeBlockItemList( + let initializerCodeBlock = CodeBlockSyntax( + leftBrace: .leftBraceToken( + leadingTrivia: .space, + trailingTrivia: storedProperties.isEmpty ? [] : .newline + ), + statements: CodeBlockItemListSyntax( storedProperties.map { property in - SyntaxFactory.makeCodeBlockItem( - item: Syntax( - SyntaxFactory.makeSequenceExpr( - elements: SyntaxFactory.makeExprList([ - ExprSyntax( - SyntaxFactory.makeMemberAccessExpr( - base: ExprSyntax( - SyntaxFactory.makeIdentifierExpr( - identifier: SyntaxFactory.makeSelfKeyword().withLeadingTrivia(parameterIndentTrivia), - declNameArguments: nil + CodeBlockItemSyntax( + item: .expr( + ExprSyntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + ExprSyntax( + MemberAccessExprSyntax( + base: ExprSyntax( + DeclReferenceExprSyntax( + baseName: .keyword(.self).with(\.leadingTrivia, parameterIndentTrivia) + ) + ), + period: .periodToken(), + declName: DeclReferenceExprSyntax( + baseName: property.identifierPattern + .withoutBackticks() + .identifier + .trimmed + ) + ) + ), + ExprSyntax( + AssignmentExprSyntax( + equal: .equalToken( + leadingTrivia: .space, + trailingTrivia: .space ) - ), - dot: SyntaxFactory.makePeriodToken(), - name: property.identifierPattern - .withoutBackticks() - .identifier - .withoutTrivia(), - declNameArguments: nil - ) - ), - ExprSyntax( - SyntaxFactory.makeAssignmentExpr( - assignToken: SyntaxFactory.makeEqualToken( - leadingTrivia: .spaces(1), - trailingTrivia: .spaces(1) ) - ) - ), - ExprSyntax( - SyntaxFactory.makeIdentifierExpr( - identifier: property.identifierPattern.identifier.appendingTrailingTrivia(.newlines(1)), - declNameArguments: nil - ) - ), - ]) + ), + ExprSyntax( + DeclReferenceExprSyntax( + baseName: property.identifierPattern.identifier.appendingTrailingTrivia(.newline) + ) + ), + ]) + ) ) - ), - semicolon: nil, - errorTokens: nil + ) ) } ), - rightBrace: SyntaxFactory.makeRightBraceToken() + rightBrace: .rightBraceToken() .withLeadingTrivia(indentTrivia, condition: !storedProperties.isEmpty) ) // Use default access level modifier or make new internal access level modifier if not present. - let newAcessLevelModifier = (accessLevelModifier ?? SyntaxFactory.makeDeclModifier(name: SyntaxFactory.makeInternalKeyword())) - .withLeadingTrivia(indentTrivia) - .withTrailingTrivia(.spaces(1)) + let newAcessLevelModifier = (accessLevelModifier ?? DeclModifierSyntax(name: .keyword(.internal))) + .with(\.leadingTrivia, indentTrivia) + .with(\.trailingTrivia, .space) // Indicating whether to assign internal access level explicitly. let skipAccessLevel = newAcessLevelModifier.name.isInternal && implicitInternal // Make initializer declaration. - let initializerDecl = SyntaxFactory.makeInitializerDecl( - attributes: nil, - modifiers: skipAccessLevel ? nil : SyntaxFactory.makeModifierList([newAcessLevelModifier]), - initKeyword: SyntaxFactory.makeInitKeyword().withLeadingTrivia(indentTrivia, condition: skipAccessLevel), - optionalMark: nil, - genericParameterClause: nil, - parameters: parameterClause, - throwsOrRethrowsKeyword: nil, - genericWhereClause: nil, + let initializerDecl = InitializerDeclSyntax( + modifiers: skipAccessLevel ? [] : DeclModifierListSyntax([newAcessLevelModifier]), + initKeyword: .keyword(.`init`).withLeadingTrivia(indentTrivia, condition: skipAccessLevel), + signature: FunctionSignatureSyntax(parameterClause: parameterClause), body: initializerCodeBlock ) // Make member declatation list. - let member = SyntaxFactory.makeMemberDeclListItem(decl: DeclSyntax(initializerDecl), semicolon: nil) + let member = MemberBlockItemSyntax(decl: DeclSyntax(initializerDecl)) // If originally has members. - if let lastMemberToken = memberList.lastToken { - let newMemberList = - SyntaxFactory - .replacingTrivia(memberList, for: lastMemberToken, trailing: .newlines(2)) - .appending(member) - let newMembers = members.withMembers(newMemberList) + if let lastMemberToken = memberList.lastToken(viewMode: .sourceAccurate) { + let newMembers = members.with(\.members, TokenSyntax.replacingTrivia(memberList, for: lastMemberToken, trailing: .newlines(2)) + [member]) let newNode = replacingMembers(node, newMembers) return visitChildren(newNode) } else { let leftBrace = members.leftBrace.withTrailingNewLinews(count: 1) - let rightBrace = members.rightBrace.withLeadingTrivia(.newlines(1) + parentIndentTrivia) - let newMembers = members.addMember(member) - .withLeftBrace(leftBrace) - .withRightBrace(rightBrace) - let newNode = replacingMembers(node, newMembers) + let rightBrace = members.rightBrace.with(\.leadingTrivia, .newline + parentIndentTrivia) + var newMembers = members + newMembers.members = members.members + [member] + let newNode = replacingMembers( + node, + newMembers + .with(\.leftBrace, leftBrace) + .with(\.rightBrace, rightBrace) + ) return visitChildren(newNode) } } @@ -288,31 +277,31 @@ private extension DefaultMemberwiseInitializerRule.Rewriter { private extension TokenSyntax { var isLet: Bool { - tokenKind == .letKeyword + tokenKind == .keyword(.let) } var isInternal: Bool { - tokenKind == .internalKeyword + tokenKind == .keyword(.internal) } func withTrailingNewLinews(count: Int) -> TokenSyntax { let newlines = trailingTrivia.numberOfNewlines - return newlines >= count ? self : withTrailingTrivia(.newlines(count - newlines)) + return newlines >= count ? self : with(\.trailingTrivia, .newlines(count - newlines)) } func withLeadingNewlines(count: Int) -> TokenSyntax { let newlines = leadingTrivia.numberOfNewlines - return newlines >= count ? self : withLeadingTrivia(.newlines(count - newlines)) + return newlines >= count ? self : with(\.leadingTrivia, .newlines(count - newlines)) } } private extension DeclModifierSyntax { var assignableToInitializer: DeclModifierSyntax? { switch name.tokenKind { - case .openKeyward: - return withName(SyntaxFactory.makePublicKeyword()) + case .keyword(.open): + return with(\.name, .keyword(.public)) - case .publicKeyword: + case .keyword(.public): return self default: @@ -325,9 +314,9 @@ private extension TypeSyntax { func transformed() -> TypeSyntax { if let iuo = self.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) { return TypeSyntax( - SyntaxFactory.makeOptionalType( + OptionalTypeSyntax( wrappedType: iuo.wrappedType, - questionMark: SyntaxFactory.makePostfixQuestionMarkToken() + questionMark: .postfixQuestionMarkToken() ) ) } @@ -339,14 +328,14 @@ private extension TypeSyntax { func attributed() -> TypeSyntax { if self.is(FunctionTypeSyntax.self) { return TypeSyntax( - SyntaxFactory.makeAttributedType( - specifier: nil, - attributes: SyntaxFactory.makeAttributeList([ - Syntax( - AttributeSyntax { builder in - builder.useAtSignToken(SyntaxFactory.makeAtSignToken()) - builder.useAttributeName(SyntaxFactory.makeIdentifier("escaping").withTrailingTrivia(.spaces(1))) - } + AttributedTypeSyntax( + attributes: AttributeListSyntax([ + .attribute( + AttributeSyntax( + atSign: .atSignToken(), + attributeName: IdentifierTypeSyntax(name: .identifier("escaping")) + .with(\.trailingTrivia, .space) + ) ) ]), baseType: self diff --git a/Tests/SwiftModCoreTests/RuleSyntaxRewriterTests.swift b/Tests/SwiftModCoreTests/RuleSyntaxRewriterTests.swift index 64a10fb..b21e0ab 100644 --- a/Tests/SwiftModCoreTests/RuleSyntaxRewriterTests.swift +++ b/Tests/SwiftModCoreTests/RuleSyntaxRewriterTests.swift @@ -6,37 +6,31 @@ final class RuleSyntaxRewriterTests: XCTestCase { let testRule = RuleSyntaxRewriter(name: "test", options: 0, format: .default) func testIgnoreCommentForMemberDeclListItem() { - let node = SyntaxFactory.makeMemberDeclListItem( + let node = MemberBlockItemSyntax( decl: DeclSyntax( - SyntaxFactory.makeVariableDecl( - attributes: nil, - modifiers: nil, - letOrVarKeyword: SyntaxFactory.makeLetKeyword(), - bindings: SyntaxFactory.makePatternBindingList([ - SyntaxFactory.makePatternBinding( + VariableDeclSyntax( + bindingSpecifier: .keyword(.let), + bindings: PatternBindingListSyntax([ + PatternBindingSyntax( pattern: PatternSyntax( - SyntaxFactory.makeIdentifierPattern( - identifier: SyntaxFactory.makeIdentifier("test") + IdentifierPatternSyntax( + identifier: .identifier("test") ) ), - typeAnnotation: nil, - initializer: SyntaxFactory.makeInitializerClause( - equal: SyntaxFactory.makeEqualToken(), - value: ExprSyntax(SyntaxFactory.makeVariableExpr("100")) - ), - accessor: nil, - trailingComma: nil + initializer: InitializerClauseSyntax( + equal: .equalToken(), + value: ExprSyntax(IntegerLiteralExprSyntax(literal: .integerLiteral("100"))) + ) ) ]) ) - ), - semicolon: nil + ) ) let notIgnoreNode = testRule.visitAny(Syntax(node)) - let ignoreTestNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore: test")))) - let ignoreOtherNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore: other")))) - let ignoreAllNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore")))) + let ignoreTestNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore: test")))) + let ignoreOtherNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore: other")))) + let ignoreAllNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore")))) XCTAssertNil(notIgnoreNode) XCTAssertNotNil(ignoreTestNode) @@ -45,16 +39,14 @@ final class RuleSyntaxRewriterTests: XCTestCase { } func testIgnoreCommentForCodeBlockItem() { - let node = SyntaxFactory.makeCodeBlockItem( - item: Syntax(SyntaxFactory.makeIdentifier("test")), - semicolon: nil, - errorTokens: nil + let node = CodeBlockItemSyntax( + item: .expr(ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier("test")))) ) let notIgnoreNode = testRule.visitAny(Syntax(node)) - let ignoreTestNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore: test")))) - let ignoreOtherNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore: other")))) - let ignoreAllNode = testRule.visitAny(Syntax(node.withLeadingTrivia(.lineComment("swift-mod-ignore")))) + let ignoreTestNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore: test")))) + let ignoreOtherNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore: other")))) + let ignoreAllNode = testRule.visitAny(Syntax(node.with(\.leadingTrivia, .lineComment("swift-mod-ignore")))) XCTAssertNil(notIgnoreNode) XCTAssertNotNil(ignoreTestNode) diff --git a/Tests/SwiftModRulesTests/DefaultAccessLevelRuleTests.swift b/Tests/SwiftModRulesTests/DefaultAccessLevelRuleTests.swift index 8a99375..b7fac6f 100644 --- a/Tests/SwiftModRulesTests/DefaultAccessLevelRuleTests.swift +++ b/Tests/SwiftModRulesTests/DefaultAccessLevelRuleTests.swift @@ -192,7 +192,7 @@ final class DefaultAccessLevelRuleTests: XCTestCase { ) } - func testClassNotTriggered() throws { + func testClassInternalNotTriggered() throws { try assertRule( defaultRule, source: """ @@ -214,6 +214,94 @@ final class DefaultAccessLevelRuleTests: XCTestCase { ) } + func testClassOpenNotTriggered() throws { + try assertRule( + defaultRule, + source: """ + open class Class {} + """, + expected: """ + open class Class {} + """ + ) + } + + func testActor() throws { + try assertRule( + defaultRule, + source: """ + @available(swift 5.1) + actor Actor { + typealias TypeAlias = Int + static let staticStored = 0 + static func staticFunction() -> Int { 0 } + var stored: Int + var computed: Int { 0 } + internal var internalProperty: Int + func function(value: Int) -> Int { value } + subscript (value: Int) -> Int { value } + init(variable: Int) { self.variable = variable } + } + """, + expected: """ + @available(swift 5.1) + public actor Actor { + public typealias TypeAlias = Int + public static let staticStored = 0 + public static func staticFunction() -> Int { 0 } + public var stored: Int + public var computed: Int { 0 } + internal var internalProperty: Int + public func function(value: Int) -> Int { value } + public subscript (value: Int) -> Int { value } + public init(variable: Int) { self.variable = variable } + } + """ + ) + } + + func testActorNested() throws { + try assertRule( + defaultRule, + source: """ + actor Actor { + actor Nested { + var stored: Int + } + } + """, + expected: """ + public actor Actor { + public actor Nested { + public var stored: Int + } + } + """ + ) + } + + func testActorNotTriggered() throws { + try assertRule( + defaultRule, + source: """ + internal actor Actor { + actor Nested { + var stored: Int + } + var stored: Int + } + """, + expected: """ + internal actor Actor { + actor Nested { + var stored: Int + } + var stored: Int + } + """ + ) + } + func testEnum() throws { try assertRule( defaultRule, diff --git a/Tests/SwiftModRulesTests/Helpers.swift b/Tests/SwiftModRulesTests/Helpers.swift index a9bdc01..8ec47f7 100644 --- a/Tests/SwiftModRulesTests/Helpers.swift +++ b/Tests/SwiftModRulesTests/Helpers.swift @@ -1,12 +1,12 @@ import Foundation import SwiftModCore -import SwiftSyntaxParser +import SwiftParser import XCTest func assertRuleDescription(_ rule: AnyRule, file: StaticString = #file, line: UInt = #line) throws { let description = type(of: rule).description let encodedOptions = try? JSONEncoder().encode(description.exampleOptions) - let exampleSyntax = try SyntaxParser.parse(source: description.exampleBefore) + let exampleSyntax = Parser.parse(source: description.exampleBefore) let exampleModified = rule.rewriter().visit(exampleSyntax).description XCTAssertFalse(description.name.isEmpty, file: file, line: line) @@ -16,7 +16,7 @@ func assertRuleDescription(_ rule: AnyRule, file: StaticString = #file, line: UI } func assertRule(_ rule: AnyRule, source: String, expected: String, file: StaticString = #file, line: UInt = #line) throws { - let syntax = try SyntaxParser.parse(source: source) + let syntax = Parser.parse(source: source) let modified = rule.rewriter().visit(syntax).description XCTAssertEqual(modified, expected, file: file, line: line) } diff --git a/Tools/Package.resolved b/Tools/Package.resolved index 465c117..d49d03a 100644 --- a/Tools/Package.resolved +++ b/Tools/Package.resolved @@ -6,44 +6,44 @@ "repositoryURL": "https://github.com/apple/swift-argument-parser.git", "state": { "branch": null, - "revision": "9f39744e025c7d377987f30b03770805dcb0bcd1", - "version": "1.1.4" + "revision": "8f4d2753f0e4778c76d5f05ad16c74f707390531", + "version": "1.2.3" } }, { - "package": "swift-format", - "repositoryURL": "https://github.com/apple/swift-format.git", + "package": "cmark-gfm", + "repositoryURL": "https://github.com/apple/swift-cmark.git", "state": { "branch": null, - "revision": "3dd9b517b9e9846435aa782d769ef5825e7c2d65", - "version": "0.50700.0" + "revision": "f218e5d7691f78b55bfa39b367763f4612486c35", + "version": "0.3.0" } }, { - "package": "SwiftSyntax", - "repositoryURL": "https://github.com/apple/swift-syntax", + "package": "swift-format", + "repositoryURL": "https://github.com/apple/swift-format.git", "state": { "branch": null, - "revision": "04d4497be6b88e524a71778d828790e9589ae1c4", - "version": "0.50700.0" + "revision": "83248b4fa37919f78ffbd4650946759bcc54c2b5", + "version": "509.0.0" } }, { - "package": "swift-system", - "repositoryURL": "https://github.com/apple/swift-system.git", + "package": "swift-markdown", + "repositoryURL": "https://github.com/apple/swift-markdown.git", "state": { "branch": null, - "revision": "836bc4557b74fe6d2660218d56e3ce96aff76574", - "version": "1.1.1" + "revision": "e4f95e2dc23097a1a9a1dfdfe3fe3ee44de77378", + "version": "0.3.0" } }, { - "package": "swift-tools-support-core", - "repositoryURL": "https://github.com/apple/swift-tools-support-core.git", + "package": "swift-syntax", + "repositoryURL": "https://github.com/apple/swift-syntax", "state": { "branch": null, - "revision": "4f07be3dc201f6e2ee85b6942d0c220a16926811", - "version": "0.2.7" + "revision": "6ad4ea24b01559dde0773e3d091f1b9e36175036", + "version": "509.0.2" } } ] diff --git a/Tools/Package.swift b/Tools/Package.swift index 2235a82..de9f7ba 100644 --- a/Tools/Package.swift +++ b/Tools/Package.swift @@ -1,10 +1,10 @@ -// swift-tools-version:5.1 +// swift-tools-version:5.9 import PackageDescription let package = Package( name: "Tools", dependencies: [ - .package(url: "https://github.com/apple/swift-format.git", .upToNextMinor(from: "0.50700.0")), + .package(url: "https://github.com/apple/swift-format.git", .upToNextMinor(from: "509.0.0")), ] )