From 1aed0f123654aac8ceb3e25a6e75017ad45e0481 Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 11:30:05 -0800 Subject: [PATCH 01/10] Support nonescaping closure parameters --- ...nctionParameterListSyntax+Extensions.swift | 25 ++++++++++++++++ .../FunctionImplementationFactory.swift | 2 +- .../SpyableMacro/Factories/SpyFactory.swift | 2 +- .../Macro/UT_SpyableMacro.swift | 30 +++++++++++++++++++ 4 files changed, 57 insertions(+), 2 deletions(-) create mode 100644 Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift diff --git a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift new file mode 100644 index 0000000..46138e0 --- /dev/null +++ b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift @@ -0,0 +1,25 @@ +import SwiftSyntax + +extension FunctionParameterListSyntax { + /// - Returns: Whether or not the parameter list supports generating and using properties to track received arguments and received invocations. + var supportsParameterTracking: Bool { + !isEmpty && !containsNonEscapingClosure + } + + /// - Returns: Whether or not the function parameter list contains a parameter that's a nonescaping closure. + private var containsNonEscapingClosure: Bool { + contains { + if $0.type.is(FunctionTypeSyntax.self) { + return true + } + guard let attributedType = $0.type.as(AttributedTypeSyntax.self), + attributedType.baseType.is(FunctionTypeSyntax.self) else { + return false + } + + return !attributedType.attributes.contains(where: { attribute in + attribute.as(AttributeSyntax.self)?.attributeName == "escaping" + }) + } + } +} diff --git a/Sources/SpyableMacro/Factories/FunctionImplementationFactory.swift b/Sources/SpyableMacro/Factories/FunctionImplementationFactory.swift index 845e3b6..006748c 100644 --- a/Sources/SpyableMacro/Factories/FunctionImplementationFactory.swift +++ b/Sources/SpyableMacro/Factories/FunctionImplementationFactory.swift @@ -76,7 +76,7 @@ struct FunctionImplementationFactory { callsCountFactory.incrementVariableExpression(variablePrefix: variablePrefix) - if !parameterList.isEmpty { + if parameterList.supportsParameterTracking { receivedArgumentsFactory.assignValueToVariableExpression( variablePrefix: variablePrefix, parameterList: parameterList diff --git a/Sources/SpyableMacro/Factories/SpyFactory.swift b/Sources/SpyableMacro/Factories/SpyFactory.swift index bf5ac6e..d27ce7e 100644 --- a/Sources/SpyableMacro/Factories/SpyFactory.swift +++ b/Sources/SpyableMacro/Factories/SpyFactory.swift @@ -129,7 +129,7 @@ struct SpyFactory { try callsCountFactory.variableDeclaration(variablePrefix: variablePrefix) try calledFactory.variableDeclaration(variablePrefix: variablePrefix) - if !parameterList.isEmpty { + if parameterList.supportsParameterTracking { try receivedArgumentsFactory.variableDeclaration( variablePrefix: variablePrefix, parameterList: parameterList diff --git a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift index d666e14..009ed78 100644 --- a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift +++ b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift @@ -33,6 +33,9 @@ final class UT_SpyableMacro: XCTestCase { func initialize(name: String, secondName: String?) func fetchConfig() async throws -> [String: String] func fetchData(_ name: (String, count: Int)) async -> (() -> Void) + func fetchUsername(context: String, completion: @escaping (String) -> Void) + func onTapBack(context: String, action: () -> Void) + func onTapNext(context: String, action: @Sendable () -> Void) } """ @@ -133,6 +136,33 @@ final class UT_SpyableMacro: XCTestCase { return fetchDataReturnValue } } + var fetchUsernameContextCompletionCallsCount = 0 + var fetchUsernameContextCompletionCalled: Bool { + return fetchUsernameContextCompletionCallsCount > 0 + } + var fetchUsernameContextCompletionClosure: ((String, @escaping (String) -> Void) -> Void)? + func fetchUsername(context: String, completion: @escaping (String) -> Void) { + fetchUsernameContextCompletionCallsCount += 1 + fetchUsernameContextCompletionClosure?(context, completion) + } + var onTapBackContextActionCallsCount = 0 + var onTapBackContextActionCalled: Bool { + return onTapBackContextActionCallsCount > 0 + } + var onTapBackContextActionClosure: ((String, () -> Void) -> Void)? + func onTapBack(context: String, action: () -> Void) { + onTapBackContextActionCallsCount += 1 + onTapBackContextActionClosure?(context, action) + } + var onTapNextContextActionCallsCount = 0 + var onTapNextContextActionCalled: Bool { + return onTapNextContextActionCallsCount > 0 + } + var onTapNextContextActionClosure: ((String, @Sendable () -> Void) -> Void)? + func onTapNext(context: String, action: @Sendable () -> Void) { + onTapNextContextActionCallsCount += 1 + onTapNextContextActionClosure?(context, action) + } } """, macros: sut From b247c28a49ed184866af40cc8d55c25358c64b49 Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 11:33:00 -0800 Subject: [PATCH 02/10] Tiny documentation update --- .../Extensions/FunctionParameterListSyntax+Extensions.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift index 46138e0..fdbb310 100644 --- a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift +++ b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift @@ -1,7 +1,7 @@ import SwiftSyntax extension FunctionParameterListSyntax { - /// - Returns: Whether or not the parameter list supports generating and using properties to track received arguments and received invocations. + /// - Returns: Whether or not the function parameter list supports generating and using properties to track received arguments and received invocations. var supportsParameterTracking: Bool { !isEmpty && !containsNonEscapingClosure } From f7c349ecac7b93bb605bc1ec82d9214bd9e95ea0 Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 11:43:47 -0800 Subject: [PATCH 03/10] Fix containsNonEscapingClosure not properly detecting the escaping attribute --- .../Extensions/FunctionParameterListSyntax+Extensions.swift | 2 +- Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift index fdbb310..f8f7084 100644 --- a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift +++ b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift @@ -18,7 +18,7 @@ extension FunctionParameterListSyntax { } return !attributedType.attributes.contains(where: { attribute in - attribute.as(AttributeSyntax.self)?.attributeName == "escaping" + attribute.as(AttributeSyntax.self)?.attributeName.as(IdentifierTypeSyntax.self)?.name.text == "escaping" }) } } diff --git a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift index 009ed78..10974b8 100644 --- a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift +++ b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift @@ -140,9 +140,13 @@ final class UT_SpyableMacro: XCTestCase { var fetchUsernameContextCompletionCalled: Bool { return fetchUsernameContextCompletionCallsCount > 0 } + var fetchUsernameContextCompletionReceivedArguments: (context: String, completion: (String) -> Void)? + var fetchUsernameContextCompletionReceivedInvocations: [(context: String, completion: (String) -> Void)] = [] var fetchUsernameContextCompletionClosure: ((String, @escaping (String) -> Void) -> Void)? func fetchUsername(context: String, completion: @escaping (String) -> Void) { fetchUsernameContextCompletionCallsCount += 1 + fetchUsernameContextCompletionReceivedArguments = (context, completion) + fetchUsernameContextCompletionReceivedInvocations.append((context, completion)) fetchUsernameContextCompletionClosure?(context, completion) } var onTapBackContextActionCallsCount = 0 From 0c1907358df032ca7653be9c9c7e1f34541dfabc Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 12:10:35 -0800 Subject: [PATCH 04/10] Support autoclosure and refactor added extensions --- ...nctionParameterListSyntax+Extensions.swift | 25 ------------- .../FunctionParameters+Extensions.swift | 36 +++++++++++++++++++ .../Factories/ClosureFactory.swift | 4 ++- .../Macro/UT_SpyableMacro.swift | 10 ++++++ 4 files changed, 49 insertions(+), 26 deletions(-) delete mode 100644 Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift create mode 100644 Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift diff --git a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift deleted file mode 100644 index f8f7084..0000000 --- a/Sources/SpyableMacro/Extensions/FunctionParameterListSyntax+Extensions.swift +++ /dev/null @@ -1,25 +0,0 @@ -import SwiftSyntax - -extension FunctionParameterListSyntax { - /// - Returns: Whether or not the function parameter list supports generating and using properties to track received arguments and received invocations. - var supportsParameterTracking: Bool { - !isEmpty && !containsNonEscapingClosure - } - - /// - Returns: Whether or not the function parameter list contains a parameter that's a nonescaping closure. - private var containsNonEscapingClosure: Bool { - contains { - if $0.type.is(FunctionTypeSyntax.self) { - return true - } - guard let attributedType = $0.type.as(AttributedTypeSyntax.self), - attributedType.baseType.is(FunctionTypeSyntax.self) else { - return false - } - - return !attributedType.attributes.contains(where: { attribute in - attribute.as(AttributeSyntax.self)?.attributeName.as(IdentifierTypeSyntax.self)?.name.text == "escaping" - }) - } - } -} diff --git a/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift new file mode 100644 index 0000000..21c819f --- /dev/null +++ b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift @@ -0,0 +1,36 @@ +import SwiftSyntax + +extension FunctionParameterListSyntax { + /// - Returns: Whether or not the function parameter list supports generating and using properties to track received arguments and received invocations. + var supportsParameterTracking: Bool { + !isEmpty && !contains { $0.containsNonEscapingClosure } + } +} + +extension FunctionParameterSyntax { + fileprivate var containsNonEscapingClosure: Bool { + if type.is(FunctionTypeSyntax.self) { + return true + } + guard let attributedType = type.as(AttributedTypeSyntax.self), + attributedType.baseType.is(FunctionTypeSyntax.self) else { + return false + } + + return !attributedType.attributes.contains { + $0.attributeNameTextMatches("escaping") + } + } + + var usesAutoclosure: Bool { + type.as(AttributedTypeSyntax.self)?.attributes.contains { + $0.attributeNameTextMatches("autoclosure") + } == true + } +} + +private extension AttributeListSyntax.Element { + func attributeNameTextMatches(_ name: String) -> Bool { + self.as(AttributeSyntax.self)?.attributeName.as(IdentifierTypeSyntax.self)?.name.text == name + } +} diff --git a/Sources/SpyableMacro/Factories/ClosureFactory.swift b/Sources/SpyableMacro/Factories/ClosureFactory.swift index 3ae7654..2ab0bd4 100644 --- a/Sources/SpyableMacro/Factories/ClosureFactory.swift +++ b/Sources/SpyableMacro/Factories/ClosureFactory.swift @@ -86,10 +86,12 @@ struct ClosureFactory { leftParen: .leftParenToken(), arguments: LabeledExprListSyntax { for parameter in functionSignature.parameterClause.parameters { + let trailingTrivia: Trivia? = parameter.usesAutoclosure ? "()" : nil LabeledExprSyntax( expression: DeclReferenceExprSyntax( baseName: parameter.secondName ?? parameter.firstName - ) + ), + trailingTrivia: trailingTrivia ) } }, diff --git a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift index 10974b8..f6260e5 100644 --- a/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift +++ b/Tests/SpyableMacroTests/Macro/UT_SpyableMacro.swift @@ -36,6 +36,7 @@ final class UT_SpyableMacro: XCTestCase { func fetchUsername(context: String, completion: @escaping (String) -> Void) func onTapBack(context: String, action: () -> Void) func onTapNext(context: String, action: @Sendable () -> Void) + func assert(_ message: @autoclosure () -> String) } """ @@ -167,6 +168,15 @@ final class UT_SpyableMacro: XCTestCase { onTapNextContextActionCallsCount += 1 onTapNextContextActionClosure?(context, action) } + var assertCallsCount = 0 + var assertCalled: Bool { + return assertCallsCount > 0 + } + var assertClosure: ((@autoclosure () -> String) -> Void)? + func assert(_ message: @autoclosure () -> String) { + assertCallsCount += 1 + assertClosure?(message()) + } } """, macros: sut From 7a83c19adb183be825f17e1d0949cd1d5eeb6794 Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 14:47:34 -0800 Subject: [PATCH 05/10] Add more tests for closure arguments --- Sources/Spyable/Spyable.swift | 10 +++ .../Factories/UT_ClosureFactory.swift | 8 +-- .../UT_FunctionImplementationFactory.swift | 48 ++++++++++++++ .../Factories/UT_SpyFactory.swift | 64 +++++++++++++++++++ 4 files changed, 126 insertions(+), 4 deletions(-) diff --git a/Sources/Spyable/Spyable.swift b/Sources/Spyable/Spyable.swift index 3045c32..72b48f9 100644 --- a/Sources/Spyable/Spyable.swift +++ b/Sources/Spyable/Spyable.swift @@ -58,3 +58,13 @@ public macro Spyable(behindPreprocessorFlag: String? = nil) = module: "SpyableMacro", type: "SpyableMacro" ) + +@Spyable +protocol MyProtocol { + func foo( +// text: inout String, + product: (UInt?, name: String), + added: (() -> Void)?, + removed: @autoclosure @escaping () -> Bool + ) async throws -> (text: String, output: (() -> Void)?) +} diff --git a/Tests/SpyableMacroTests/Factories/UT_ClosureFactory.swift b/Tests/SpyableMacroTests/Factories/UT_ClosureFactory.swift index 8e0d637..5f59e36 100644 --- a/Tests/SpyableMacroTests/Factories/UT_ClosureFactory.swift +++ b/Tests/SpyableMacroTests/Factories/UT_ClosureFactory.swift @@ -123,7 +123,7 @@ final class UT_ClosureFactory: XCTestCase { text: inout String, product: (UInt?, name: String), added: (() -> Void)?, - removed: @escaping () -> Bool + removed: @autoclosure @escaping () -> Bool ) async throws -> (text: String, output: (() -> Void)?) """ ) {} @@ -136,7 +136,7 @@ final class UT_ClosureFactory: XCTestCase { assertBuildResult( result, """ - var fooClosure: ((inout String, (UInt?, name: String), (() -> Void)?, @escaping () -> Bool) async throws -> (text: String, output: (() -> Void)?) )? + var fooClosure: ((inout String, (UInt?, name: String), (() -> Void)?, @autoclosure @escaping () -> Bool) async throws -> (text: String, output: (() -> Void)?) )? """ ) } @@ -234,7 +234,7 @@ final class UT_ClosureFactory: XCTestCase { let protocolFunctionDeclaration = try FunctionDeclSyntax( """ - func foo(text: inout String, product: (UInt?, name: String), added: (() -> Void)?, removed: @escaping () -> Bool) async throws -> String? + func foo(text: inout String, product: (UInt?, name: String), added: (() -> Void)?, removed: @autoclosure @escaping () -> Bool) async throws -> String? """ ) {} @@ -246,7 +246,7 @@ final class UT_ClosureFactory: XCTestCase { assertBuildResult( result, """ - try await fooClosure!(text, product, added, removed) + try await fooClosure!(text, product, added, removed()) """ ) } diff --git a/Tests/SpyableMacroTests/Factories/UT_FunctionImplementationFactory.swift b/Tests/SpyableMacroTests/Factories/UT_FunctionImplementationFactory.swift index 7d052c4..fcca023 100644 --- a/Tests/SpyableMacroTests/Factories/UT_FunctionImplementationFactory.swift +++ b/Tests/SpyableMacroTests/Factories/UT_FunctionImplementationFactory.swift @@ -133,4 +133,52 @@ final class UT_FunctionImplementationFactory: XCTestCase { """ ) } + + func testDeclarationWithEscapingAutoClosure() throws { + let variablePrefix = "functionName" + + let protocolFunctionDeclaration = try FunctionDeclSyntax( + "func foo(action: @autoclosure @escaping () -> Void)" + ) {} + + let result = FunctionImplementationFactory().declaration( + variablePrefix: variablePrefix, + protocolFunctionDeclaration: protocolFunctionDeclaration + ) + + assertBuildResult( + result, + """ + func foo(action: @autoclosure @escaping () -> Void) { + functionNameCallsCount += 1 + functionNameReceivedAction = (action) + functionNameReceivedInvocations.append((action)) + functionNameClosure?(action()) + } + """ + ) + } + + func testDeclarationWithNonEscapingClosure() throws { + let variablePrefix = "functionName" + + let protocolFunctionDeclaration = try FunctionDeclSyntax( + "func foo(action: () -> Void)" + ) {} + + let result = FunctionImplementationFactory().declaration( + variablePrefix: variablePrefix, + protocolFunctionDeclaration: protocolFunctionDeclaration + ) + + assertBuildResult( + result, + """ + func foo(action: () -> Void) { + functionNameCallsCount += 1 + functionNameClosure?(action) + } + """ + ) + } } diff --git a/Tests/SpyableMacroTests/Factories/UT_SpyFactory.swift b/Tests/SpyableMacroTests/Factories/UT_SpyFactory.swift index 52f0b27..401a68c 100644 --- a/Tests/SpyableMacroTests/Factories/UT_SpyFactory.swift +++ b/Tests/SpyableMacroTests/Factories/UT_SpyFactory.swift @@ -88,6 +88,70 @@ final class UT_SpyFactory: XCTestCase { ) } + func testDeclarationEscapingAutoClosureArgument() throws { + let declaration = DeclSyntax( + """ + protocol ViewModelProtocol { + func foo(action: @escaping @autoclosure () -> Void) + } + """ + ) + let protocolDeclaration = try XCTUnwrap(ProtocolDeclSyntax(declaration)) + + let result = try SpyFactory().classDeclaration(for: protocolDeclaration) + + assertBuildResult( + result, + """ + class ViewModelProtocolSpy: ViewModelProtocol { + var fooActionCallsCount = 0 + var fooActionCalled: Bool { + return fooActionCallsCount > 0 + } + var fooActionReceivedAction: (() -> Void)? + var fooActionReceivedInvocations: [() -> Void] = [] + var fooActionClosure: ((@escaping @autoclosure () -> Void) -> Void)? + func foo(action: @escaping @autoclosure () -> Void) { + fooActionCallsCount += 1 + fooActionReceivedAction = (action) + fooActionReceivedInvocations.append((action)) + fooActionClosure?(action()) + } + } + """ + ) + } + + func testDeclarationNonescapingClosureArgument() throws { + let declaration = DeclSyntax( + """ + protocol ViewModelProtocol { + func foo(action: () -> Void) + } + """ + ) + let protocolDeclaration = try XCTUnwrap(ProtocolDeclSyntax(declaration)) + + let result = try SpyFactory().classDeclaration(for: protocolDeclaration) + + assertBuildResult( + result, + """ + class ViewModelProtocolSpy: ViewModelProtocol { + var fooActionCallsCount = 0 + var fooActionCalled: Bool { + return fooActionCallsCount > 0 + } + var fooActionClosure: ((() -> Void) -> Void)? + func foo(action: () -> Void) { + fooActionCallsCount += 1 + fooActionClosure?(action) + } + } + """ + ) + } + func testDeclarationReturnValue() throws { let declaration = DeclSyntax( """ From ed1a67173c4858407265e776ca8ee031324c3678 Mon Sep 17 00:00:00 2001 From: David Furman Date: Thu, 23 Nov 2023 15:01:37 -0800 Subject: [PATCH 06/10] Remove debugging code --- Sources/Spyable/Spyable.swift | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/Sources/Spyable/Spyable.swift b/Sources/Spyable/Spyable.swift index 72b48f9..3045c32 100644 --- a/Sources/Spyable/Spyable.swift +++ b/Sources/Spyable/Spyable.swift @@ -58,13 +58,3 @@ public macro Spyable(behindPreprocessorFlag: String? = nil) = module: "SpyableMacro", type: "SpyableMacro" ) - -@Spyable -protocol MyProtocol { - func foo( -// text: inout String, - product: (UInt?, name: String), - added: (() -> Void)?, - removed: @autoclosure @escaping () -> Bool - ) async throws -> (text: String, output: (() -> Void)?) -} From cfb3c1c1aead34949e0b9c5799faf3d8b582e0b9 Mon Sep 17 00:00:00 2001 From: David Furman Date: Sun, 26 Nov 2023 16:05:50 -0800 Subject: [PATCH 07/10] Create UT_FunctionParameterListSyntax+Extensions.swift --- ...nctionParameterListSyntax+Extensions.swift | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift diff --git a/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift b/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift new file mode 100644 index 0000000..71ad113 --- /dev/null +++ b/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift @@ -0,0 +1,22 @@ +import SwiftSyntax +import XCTest + +@testable import SpyableMacro + +final class UT_FunctionParameterListSyntaxExtensions: XCTestCase { + func testSupportsParameterTracking() { + XCTAssertTrue( + FunctionParameterListSyntax { + "param: Int" + "param: inout Int" + "param: @autoclosure @escaping (Int) throws async -> Void" + }.supportsParameterTracking + ) + + XCTAssertFalse( + FunctionParameterListSyntax { + "param: (Int) -> Void" + }.supportsParameterTracking + ) + } +} From 20efea9ade32910cd2a3db29478fe4b1566d4663 Mon Sep 17 00:00:00 2001 From: David Furman Date: Sun, 31 Dec 2023 12:15:45 -0800 Subject: [PATCH 08/10] Update Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mateusz Bąk --- .../SpyableMacro/Extensions/FunctionParameters+Extensions.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift index 21c819f..5ac86de 100644 --- a/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift +++ b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift @@ -18,7 +18,7 @@ extension FunctionParameterSyntax { } return !attributedType.attributes.contains { - $0.attributeNameTextMatches("escaping") + $0.attributeNameTextMatches(TokenSyntax.keyword(.escaping).text) } } From dc82ae8ee738f0851e9fdcb13dc5145010341e0c Mon Sep 17 00:00:00 2001 From: David Furman Date: Sun, 31 Dec 2023 12:15:51 -0800 Subject: [PATCH 09/10] Update Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mateusz Bąk --- .../SpyableMacro/Extensions/FunctionParameters+Extensions.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift index 5ac86de..a2f63a8 100644 --- a/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift +++ b/Sources/SpyableMacro/Extensions/FunctionParameters+Extensions.swift @@ -24,7 +24,7 @@ extension FunctionParameterSyntax { var usesAutoclosure: Bool { type.as(AttributedTypeSyntax.self)?.attributes.contains { - $0.attributeNameTextMatches("autoclosure") + $0.attributeNameTextMatches(TokenSyntax.keyword(.autoclosure).text) } == true } } From 9e76c1b406342690de3a23457694a2b347dcbbd5 Mon Sep 17 00:00:00 2001 From: David Furman Date: Sun, 31 Dec 2023 12:16:03 -0800 Subject: [PATCH 10/10] Update Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mateusz Bąk --- .../Extensions/UT_FunctionParameterListSyntax+Extensions.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift b/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift index 71ad113..d5996dc 100644 --- a/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift +++ b/Tests/SpyableMacroTests/Extensions/UT_FunctionParameterListSyntax+Extensions.swift @@ -9,7 +9,7 @@ final class UT_FunctionParameterListSyntaxExtensions: XCTestCase { FunctionParameterListSyntax { "param: Int" "param: inout Int" - "param: @autoclosure @escaping (Int) throws async -> Void" + "param: @autoclosure @escaping (Int) async throws -> Void" }.supportsParameterTracking )