Escape closure

Sources/DIGenKit/Generating/ResolveMethod.swift

@@ -65,7 +65,15 @@ struct ResolveMethod {
 
         parameters = node.deepDependencyParameters.map { Parameter(name: $0.name, typeName: $0.typeName) }
         parametersDeclaration = parameters
-            .map { "\($0.name): \($0.typeName)" }
+            .map {
+                let typeName = $0.typeName
+                if typeName.contains("->") {
+                    // FIXME: This condition is insufficient. It mistakes in case such as `(() -> Void)?` `Foo<() -> Void>` `(Bar, () -> Void)`
+                    return "\($0.name): @escaping \(typeName)"
+                } else {
+                    return "\($0.name): \(typeName)"
+                }
+            }
             .joined(separator: ", ")
     }
 }

Tests/DIGenKitTests/CodeGeneratorTests.swift

@@ -54,4 +54,48 @@ final class CodeGeneratorTests: XCTestCase {
         }
         """)
     }
+
+    func testProperties() throws {
+        let code = """
+            import DIKit
+
+            struct A: Injectable {
+                struct Dependency {
+                    let value: Int
+                    let closure1: (Int) -> Void
+                    let closure2: (Int) throws -> Void
+            //        let closure3: ((Int) -> Void)?
+            //        let closure4: Optional<(Int) -> Void>
+            //        let closure5: (Bool, (Int) -> Void)
+                }
+
+                init(dependency: Dependency) {}
+            }
+
+            protocol TestResolver: Resolver {
+            }
+            """
+
+        let file = File(contents: code)
+        let generator = try CodeGenerator(files: [file])
+        let contents = try generator.generate().trimmingCharacters(in: .whitespacesAndNewlines)
+
+        // Generated code uses provider method only
+        XCTAssertEqual(contents, """
+        //
+        //  Resolver.swift
+        //  Generated by dikitgen.
+        //
+
+        import DIKit
+
+        extension TestResolver {
+
+            func resolveA(value: Int, closure1: @escaping (Int) -> Void, closure2: @escaping (Int) throws -> Void) -> A {
+                return A(dependency: .init(value: value, closure1: closure1, closure2: closure2))
+            }
+
+        }
+        """)
+    }
 }