Make where clause and generic parameter detection shorter

rocxteady · Oct 25, 2023 · 9fb57ac · 9fb57ac
1 parent d26ccbf
commit 9fb57ac
Show file tree

Hide file tree

Showing 3 changed files with 18 additions and 23 deletions.
diff --git a/Sources/ThrowPublisherClient/main.swift b/Sources/ThrowPublisherClient/main.swift
@@ -31,7 +31,14 @@ struct MyStruct {
     }
 
     @ThrowPublisher
-    func doSomething<T>(arg: T) throws -> String where T: Equatable {
+    func doSomething<T, P>(arg: T, arg2: P) throws -> String where T: Equatable {
+        "Something"
+    }
+}
+
+extension Array {
+    @ThrowPublisher
+    func doSomething(arg: String) throws -> String where Self.Element == Int {
         "Something"
     }
 }

diff --git a/Sources/ThrowPublisherMacros/ThrowPublisherMacro.swift b/Sources/ThrowPublisherMacros/ThrowPublisherMacro.swift
@@ -10,7 +10,6 @@ enum ThrowPublisherError: Error, CustomStringConvertible {
     case identifierType
     case asyncSpecifier
     case noThrow
-    case unsupportedWhereClause
 
     var description: String {
         switch self {
@@ -22,8 +21,6 @@ enum ThrowPublisherError: Error, CustomStringConvertible {
             return "Could not get the name of wildcard(_) parameter."
         case .asyncSpecifier:
             return "ThrowPublisher doesn't support async specifier."
-        case .unsupportedWhereClause:
-            return "Unsupported where clause."
         case .noThrow:
             return "Function doesn't throw."
         }
@@ -61,21 +58,12 @@ public struct ThrowPublisherMacro: PeerMacro {
        var newFunctionName = "\(functionName)_publisher"
 
        if let genericParameterClause = functionDecl.genericParameterClause {
-           let generics = genericParameterClause.parameters.map {
-               $0.name.text
-           }.joined(separator: ", ")
-           newFunctionName += "<\(generics)>"
+           newFunctionName += "\(genericParameterClause)"
        }
 
        var genericPart: String?
        if let genericWhereClause = functionDecl.genericWhereClause {
-           let generics = try genericWhereClause.requirements.map {
-               guard let conformanceRequirementSyntax = $0.requirement.as(ConformanceRequirementSyntax.self),
-                     let leftType = conformanceRequirementSyntax.leftType.as(IdentifierTypeSyntax.self),
-                     let rightType = conformanceRequirementSyntax.rightType.as(IdentifierTypeSyntax.self)else { throw ThrowPublisherError.unsupportedWhereClause }
-               return "\(leftType.name.text)\(conformanceRequirementSyntax.colon.text) \(rightType.name.text)"
-           }.joined(separator: ", ")
-           genericPart = "where \(generics)"
+           genericPart = "where \(genericWhereClause.requirements)"
        }
 
        let parameters = "\(functionDecl.signature.parameterClause)"
@@ -110,7 +98,7 @@ public struct ThrowPublisherMacro: PeerMacro {
            startOfFunction = "\(modifiers) \(startOfFunction)"
        }
        let hop = """
-       \(startOfFunction) \(newFunctionName)\(parameters)-> \(returnPart) {
+       \(startOfFunction) \(newFunctionName)\(parameters)-> \(returnPart){
            func getResult() -> Result<\(returnType), Error> {
                do {
                    \(resultString)

diff --git a/Tests/ThrowPublisherTests/ThrowPublisherTests.swift b/Tests/ThrowPublisherTests/ThrowPublisherTests.swift
@@ -157,19 +157,19 @@ final class ThrowPublisherTests: XCTestCase {
         assertMacroExpansion(
             """
             @ThrowPublisher
-            func someFunc<T>(arg1: T) throws -> String {
+            func someFunc<T, P>(arg1: T, arg2: P) throws -> String {
                 "something"
             }
             """,
             expandedSource: """
-            func someFunc<T>(arg1: T) throws -> String {
+            func someFunc<T, P>(arg1: T, arg2: P) throws -> String {
                 "something"
             }
 
-            func someFunc_publisher<T>(arg1: T) -> AnyPublisher<String, Error> {
+            func someFunc_publisher<T, P>(arg1: T, arg2: P) -> AnyPublisher<String, Error> {
                 func getResult() -> Result<String, Error> {
                     do {
-                        let result = try someFunc(arg1: arg1)
+                        let result = try someFunc(arg1: arg1, arg2: arg2)
                         return .success(result)
                     } catch {
                         return .failure(error)
@@ -227,16 +227,16 @@ final class ThrowPublisherTests: XCTestCase {
         assertMacroExpansion(
             """
             @ThrowPublisher
-            func someFunc<T>(arg1: T) throws -> String where T: Equatable {
+            func someFunc<T>(arg1: T) throws -> String where T: Equatable, Self.Element == Int {
                 "something"
             }
             """,
             expandedSource: """
-            func someFunc<T>(arg1: T) throws -> String where T: Equatable {
+            func someFunc<T>(arg1: T) throws -> String where T: Equatable, Self.Element == Int {
                 "something"
             }
 
-            func someFunc_publisher<T>(arg1: T) -> AnyPublisher<String, Error> where T: Equatable {
+            func someFunc_publisher<T>(arg1: T) -> AnyPublisher<String, Error> where T: Equatable, Self.Element == Int {
                 func getResult() -> Result<String, Error> {
                     do {
                         let result = try someFunc(arg1: arg1)