Support @autoclosure within arguments at @DependencyEndpoint

[xiii111]

Resolve #155

Cause

struct Foo {
  @DependencyEndpoint
  var bar: (_ a: Int) -> Void
}

In general, the above code can typically be transformed into the following code without any issue. This is because the type of argument a passed to func bar matches the type of the argument a passed to var bar.

func bar(a p0: Int) -> Void {
  self.bar(p0)
}

This also applies to simple closures.

struct Foo {
  @DependencyEndpoint
  var bar: (_ a: () -> Int) -> Void
}

func bar(a p0: () -> Int) -> Void {
  self.bar(p0)
}

However, when considering closures marked with @autoclosure, the type of the argument a passed to func bar might not match the type of the argument a when passing to var bar.

struct Foo {
  @DependencyEndpoint
  var bar: (_ a: () @autoclosure -> Int) -> Void
}

func bar(a p0: @autoclosure () -> Int) -> Void {
  self.bar(p0) // Error occurs: 'Add () to forward @autoclosure parameter'
}

Solution

Simply adding () should resolve this bug.

struct Foo {
  @DependencyEndpoint
  var bar: (_ a: () @autoclosure -> Int) -> Void
}

func bar(a p0: @autoclosure () -> Int) -> Void {
  self.bar(p0()) // No Error occurs
}

Concern

I might be overly concerned, but I feel there's a slight difference between directly invoking var bar and indirectly through func bar. When directly calling var bar, it receives () -> String. However, when calling var bar indirectly through func bar, it receives () -> (() -> String)(). I don't expect this difference to cause any change in behavior, but if there might be an issue, I'd appreciate some advice!

[xiii111]

#159 style seemed so cool that I had to try it myself. Originally, I was writing code like this 😅

let appliedParameters =
  parameters
  .enumerated()
  .map {
    if let typed = $1.type.as(AttributedTypeSyntax.self),
       typed.specifier?.tokenKind == .keyword(.inout) {
      return "&p\($0)"
    }
    
    if let typed = $1.type.as(AttributedTypeSyntax.self),
       typed.attributes.contains(where: {
         $0.as(AttributeSyntax.self)?.attributeName.as(IdentifierTypeSyntax.self)?.name.tokenKind == .identifier("autoclosure")
       }) {
      return "p\($0)()"
    }

    return "p\($0)"
  }
  .joined(separator: ", ")

[xiii111]

#159 uses text but I thought tokenKind might be a bit better. Since I'm new to SwiftSyntax, I'll respect your choice.

[xiii111]

To obtain this code, I used the Swift AST Explorer. When I input

var bar: (_ a: @autoclosure () -> Int) -> Void

it produced the following output.

[xiii111]

I used the same naming with #159, like Foo and Bar. The difference from #159 lies in using b as a closure. My intension is to show the difference between closures with and without @autoclosure.

[xiii111]

Only () is OK because @autoclosure can be used only when there are no parameters.
Also inout expression cannot be used on @autoclosure so we don't need to consider the situation when $1.isInout && $1.isAutoclosure.

[mbrandonw]

Thanks for taking the time to PR this!

[mbrandonw]

Great, thanks @xiii111!

[xiii111]

@mbrandonw Thank you!