expo-modules-macros 0.20.0 → 0.22.0

package/apple/Package.resolved

@@ -1,13 +1,13 @@
 {
-  "originHash" : "f142f4d4b3ea8f139f9a2f206e382cf98031da4c8ea8691ddec05cb0c9d2285f",
+  "originHash" : "a90a0c6d6b4023098b6a673ded4f314ec06c219ded1559e5d5595f23c7dc323b",
   "pins" : [
     {
       "identity" : "swift-syntax",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/swiftlang/swift-syntax.git",
       "state" : {
-        "revision" : "79e4b74a295b6eb74a8b585e3a39d29e70c1dbd1",
-        "version" : "603.0.2"
+        "revision" : "050f1a346fbbac0ca2cfb15a95274f7bd1cf0ccf",
+        "version" : "604.0.0"
       }
     }
   ],

package/apple/Package.swift

@@ -9,7 +9,7 @@ let package = Package(
   name: "ExpoModulesMacros",
   platforms: [.macOS(.v13)],
   dependencies: [
-    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "603.0.0-latest")
+    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "604.0.0-latest")
   ],
   targets: [
     // The plugin executable doubles as the scanner CLI: the compiler launches it without arguments
@@ -44,7 +44,6 @@ if FileManager.default.fileExists(atPath: Context.packageDirectory + "/Tests") {
       name: "ExpoModulesMacrosTests",
       dependencies: [
         "ExpoModulesMacros",
-        .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
         .product(name: "SwiftSyntaxMacrosGenericTestSupport", package: "swift-syntax"),
       ]
     )

package/apple/Sources/ExpoModulesMacros/ClosureArguments.swift

@@ -189,7 +189,9 @@ internal func diagnoseClosureTypes(
           message: ClosureDiagnosticMessage(
             "A @JS function can't return a closure: a native closure can't be encoded to a JavaScript function.",
             id: "js-closure-return"
-          )))
+          )
+        )
+      )
     }
     return
   }
@@ -199,14 +201,17 @@ internal func diagnoseClosureTypes(
   }
   if let varDecl = declaration.as(VariableDeclSyntax.self),
     let type = varDecl.bindings.first?.typeAnnotation?.type,
-    let nested = firstFunctionType(in: type) {
+    let nested = firstFunctionType(in: type)
+  {
     context.diagnose(
       Diagnostic(
         node: nested,
         message: ClosureDiagnosticMessage(
           "A @JS property can't have a closure type: a native closure can't be encoded to a JavaScript function.",
           id: "js-closure-property"
-        )))
+        )
+      )
+    )
   }
 }
 
@@ -223,7 +228,9 @@ private func diagnoseClosureParameters(
             message: ClosureDiagnosticMessage(
               "A closure in a @JS argument must be the argument's own type, optionally wrapped in an optional. Closures inside other types, such as arrays or dictionaries, aren't supported.",
               id: "js-closure-nested-in-type"
-            )))
+            )
+          )
+        )
       }
       continue
     }
@@ -245,7 +252,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
         message: ClosureDiagnosticMessage(
           "'@\(name)' isn't supported on a @JS closure argument. The closure calls JavaScript through its own thread hop, so only '@escaping' and '@Sendable' are allowed.",
           id: "js-closure-attribute"
-        )))
+        )
+      )
+    )
   }
 
   if let throwsClause = functionType.effectSpecifiers?.throwsClause, throwsClause.type != nil {
@@ -255,7 +264,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
         message: ClosureDiagnosticMessage(
           "A @JS closure argument can't use typed throws: the error from JavaScript can be any error. Write 'throws' without a type.",
           id: "js-closure-typed-throws"
-        )))
+        )
+      )
+    )
   }
 
   for parameter in closure.parameters {
@@ -266,7 +277,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           message: ClosureDiagnosticMessage(
             "A @JS closure argument can't take an '\(specifier)' parameter: its value is encoded and sent to JavaScript, which can't write it back or share its isolation.",
             id: "js-closure-parameter-specifier"
-          )))
+          )
+        )
+      )
     }
     if parameter.isVariadic {
       context.diagnose(
@@ -275,7 +288,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           message: ClosureDiagnosticMessage(
             "A @JS closure argument can't take a variadic parameter. Use an array instead.",
             id: "js-closure-variadic-parameter"
-          )))
+          )
+        )
+      )
     }
   }
 
@@ -290,7 +305,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           message: ClosureDiagnosticMessage(
             "A @JS closure argument can't take or return another closure.",
             id: "js-closure-nested"
-          )))
+          )
+        )
+      )
     } else if mentionsFreeFormAny(type) {
       context.diagnose(
         Diagnostic(
@@ -298,7 +315,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           message: ClosureDiagnosticMessage(
             "A @JS closure argument can't use the free-form '\(type.trimmedDescription)'. Use a concrete type, or 'JavaScriptValue' to pass a JS value through unchanged.",
             id: "js-closure-free-form"
-          )))
+          )
+        )
+      )
     }
   }
 
@@ -310,7 +329,9 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           "A @JS closure argument that returns a value must be 'throws': when the JavaScript function throws, the closure has no value to return.",
           id: "js-closure-requires-throws"
         ),
-        fixIts: [insertThrowsFixIt(for: functionType)]))
+        fixIts: [insertThrowsFixIt(for: functionType)]
+      )
+    )
   }
 }
 
@@ -321,13 +342,16 @@ private func insertThrowsFixIt(for functionType: FunctionTypeSyntax) -> FixIt {
   var newType = functionType
   if var effectSpecifiers = functionType.effectSpecifiers, let asyncSpecifier = effectSpecifiers.asyncSpecifier {
     effectSpecifiers.throwsClause = ThrowsClauseSyntax(
-      throwsSpecifier: .keyword(.throws, trailingTrivia: asyncSpecifier.trailingTrivia))
+      throwsSpecifier: .keyword(.throws, trailingTrivia: asyncSpecifier.trailingTrivia)
+    )
     effectSpecifiers.asyncSpecifier = asyncSpecifier.with(\.trailingTrivia, .space)
     newType.effectSpecifiers = effectSpecifiers
   } else {
     newType.effectSpecifiers = TypeEffectSpecifiersSyntax(
       throwsClause: ThrowsClauseSyntax(
-        throwsSpecifier: .keyword(.throws, trailingTrivia: functionType.rightParen.trailingTrivia)))
+        throwsSpecifier: .keyword(.throws, trailingTrivia: functionType.rightParen.trailingTrivia)
+      )
+    )
     newType.rightParen = functionType.rightParen.with(\.trailingTrivia, .space)
   }
   return FixIt(
@@ -360,7 +384,8 @@ internal func firstFunctionType(in type: some SyntaxProtocol) -> FunctionTypeSyn
 /// same type as `(Int) -> Void`.
 private func unparenthesized(_ type: TypeSyntax) -> TypeSyntax {
   if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1,
-    let element = tuple.elements.first, element.firstName == nil {
+    let element = tuple.elements.first, element.firstName == nil
+  {
     return unparenthesized(element.type)
   }
   return type

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -13,20 +13,32 @@ import SwiftSyntax
 /// unwrap, arity guard, argument decode, all while `this` and the arguments are still valid)
 /// and returns the async body (call and result encode), so nothing JSI-owned crosses the asynchronous
 /// boundary and JS gets a promise.
+///
+/// A synchronous function marked `@JS(.withAsync("name"))` also binds a promise-returning variant
+/// under that name (see `asyncVariant`). It decodes and encodes like an `async` function, and calls
+/// the function on the concurrent pool.
 internal struct JSFunction {
   let swiftName: String
-  let jsName: String
+  private(set) var jsName: String
   let parameters: [FunctionParameterSyntax]
   /// The declared return type as written, or `nil` when the function returns `Void`/nothing.
   let returnType: String?
   /// How the return value encodes when its type mentions `Any`, or `nil` for any other type.
   let returnFreeForm: FreeFormConversion?
   let isThrowing: Bool
-  let isAsync: Bool
+  private(set) var isAsync: Bool
+  /// The function's name in the source, where a JavaScript name collision is reported.
+  private(set) var nameToken: TokenSyntax
+  /// The name from `.withAsync("name")` and its token, or `nil` when the attribute doesn't list it.
+  private var asyncVariantName: (name: String, token: TokenSyntax)?
+  /// True for the binding `asyncVariant` returns: it calls the synchronous function on the concurrent
+  /// pool instead of on the JavaScript thread.
+  private(set) var isAsyncVariant = false
 
   init(funcDecl: FunctionDeclSyntax, attribute: AttributeSyntax) {
     self.swiftName = funcDecl.name.text
     self.jsName = jsNameArgument(of: attribute) ?? withoutBackticks(funcDecl.name.text)
+    self.nameToken = funcDecl.name
     self.parameters = Array(funcDecl.signature.parameterClause.parameters)
 
     let declaredReturnType = funcDecl.signature.returnClause?.type
@@ -36,6 +48,23 @@ internal struct JSFunction {
     let effectSpecifiers = funcDecl.signature.effectSpecifiers
     self.isThrowing = effectSpecifiers?.throwsClause?.throwsSpecifier != nil
     self.isAsync = effectSpecifiers?.asyncSpecifier != nil
+    self.asyncVariantName = asyncVariantOption(of: attribute).flatMap(asyncVariantName(of:))
+  }
+
+  /// The promise-returning binding that `.withAsync("name")` adds next to a synchronous function, or
+  /// `nil` when the attribute doesn't list it. An `async` function gets none: `@JS` reports the option
+  /// there.
+  var asyncVariant: JSFunction? {
+    guard let asyncVariantName, !isAsync else {
+      return nil
+    }
+    var variant = self
+    variant.jsName = asyncVariantName.name
+    variant.nameToken = asyncVariantName.token
+    variant.isAsync = true
+    variant.isAsyncVariant = true
+    variant.asyncVariantName = nil
+    return variant
   }
 
   /// The number of leading parameters that must always be supplied: the total minus the maximal
@@ -76,14 +105,16 @@ internal struct JSFunction {
         guard arguments.count == \(maximum) else {
           throw Exceptions.ArgumentsRangeMismatch((functionName: "\(jsName)", received: arguments.count, required: \(required), maximum: \(maximum)))
         }
-        """)
+        """
+      )
     } else {
       lines.append(
         """
         guard arguments.count >= \(required) && arguments.count <= \(maximum) else {
           throw Exceptions.ArgumentsRangeMismatch((functionName: "\(jsName)", received: arguments.count, required: \(required), maximum: \(maximum)))
         }
-        """)
+        """
+      )
     }
 
     // Decode the required prefix once — these slots are present in every accepted arity, so the
@@ -139,7 +170,8 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines())
     }
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { indent + $0 }
       .joined(separator: "\n")
@@ -149,14 +181,22 @@ internal struct JSFunction {
   /// the function's async body (`AsyncFunctionBody`), awaiting the call and encoding the result. It
   /// captures only what the call needs — the decoded `arg<i>` locals, the receiver, and `runtime`
   /// for the encode — never `this` or the arguments buffer, which are only valid for the duration
-  /// of the host call.
+  /// of the host call. The `asyncVariant` binding awaits its call on the concurrent pool instead.
   private func asyncBodyLines(receiver: Receiver, arity: Int) -> [String] {
     var lines: [String] = ["return {"]
+    let call =
+      isAsyncVariant
+      ? concurrentCallExpression(receiver: receiver, arity: arity)
+      : callExpression(receiver: receiver, arity: arity)
+    // The concurrent call spans several lines, so each of its lines is indented into the body.
+    let indented = { (statement: String) in
+      statement.split(separator: "\n", omittingEmptySubsequences: false).map { "  " + $0 }
+    }
     if returnType != nil {
-      lines.append("  let result = \(callExpression(receiver: receiver, arity: arity))")
+      lines.append(contentsOf: indented("let result = \(call)"))
       lines.append(contentsOf: encodeResultLines().map { "  " + $0 })
     } else {
-      lines.append("  \(callExpression(receiver: receiver, arity: arity))")
+      lines.append(contentsOf: indented(call))
       lines.append("  return .undefined()")
     }
     lines.append("}")
@@ -176,10 +216,36 @@ internal struct JSFunction {
     )
   }
 
-  /// The `<callee>.<name>(...)` call for the given arity. Slots `0..<arity` are passed their decoded
+  /// The `<callee>.<name>(...)` call for the given arity, with the arguments from `callArguments`.
+  private func callExpression(receiver: Receiver, arity: Int) -> String {
+    // `try` only for a throwing function. An `async` call that doesn't throw must not get one, or the
+    // expansion warns that no throwing call occurs within the `try` expression.
+    let tryKeyword = isThrowing ? "try " : ""
+    let awaitKeyword = isAsync ? "await " : ""
+    return "\(tryKeyword)\(awaitKeyword)\(receiver.callee).\(swiftName)(\(callArguments(arity: arity)))"
+  }
+
+  /// The call of the `asyncVariant` binding for the given arity: the synchronous function runs in a
+  /// `@concurrent` closure, so it leaves the JavaScript thread, and the body continues once it returns.
+  private func concurrentCallExpression(receiver: Receiver, arity: Int) -> String {
+    // The closure captures the receiver and the decoded arguments, so Swift 6 requires them to be
+    // `Sendable`, as it does for the receiver and arguments of a `.concurrent` call. The signature is
+    // spelled out because `@concurrent` needs an `async` closure, and a body without `await` would
+    // infer a synchronous one.
+    let tryKeyword = isThrowing ? "try " : ""
+    let effects = isThrowing ? "async throws" : "async"
+    let returnClause = returnType.map { " -> \(expressionType($0))" } ?? ""
+    return """
+      \(tryKeyword)await { @concurrent () \(effects)\(returnClause) in
+        \(tryKeyword)\(receiver.callee).\(swiftName)(\(callArguments(arity: arity)))
+      }()
+      """
+  }
+
+  /// The argument list of a call for the given arity. Slots `0..<arity` are passed their decoded
   /// `arg<i>`; a trailing optional-without-default slot that this arity omits is passed `nil`; a
   /// trailing defaulted slot that this arity omits is dropped entirely so Swift applies its default.
-  private func callExpression(receiver: Receiver, arity: Int) -> String {
+  private func callArguments(arity: Int) -> String {
     var callArguments: [String] = []
     for (index, parameter) in parameters.enumerated() {
       let label = parameter.firstName.text
@@ -198,11 +264,7 @@ internal struct JSFunction {
       }
       callArguments.append(label == "_" ? value : "\(label): \(value)")
     }
-    // `try` only for a throwing function. An `async` call that doesn't throw must not get one, or the
-    // expansion warns that no throwing call occurs within the `try` expression.
-    let tryKeyword = isThrowing ? "try " : ""
-    let awaitKeyword = isAsync ? "await " : ""
-    return "\(tryKeyword)\(awaitKeyword)\(receiver.callee).\(swiftName)(\(callArguments.joined(separator: ", ")))"
+    return callArguments.joined(separator: ", ")
   }
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
@@ -313,6 +375,8 @@ internal struct JSProperty {
   /// Whether the property is settable from JS: `true` for a stored `var` or a computed `var` with an
   /// explicit `set` accessor; `false` for a getter-only computed `var` or a `let`.
   let isSettable: Bool
+  /// The property's name in the source, where a JavaScript name collision is reported.
+  let nameToken: TokenSyntax
 
   /// The statements that install this property's accessor on the JS object, indented for the
   /// decorator body. Builds a descriptor object (`enumerable` + `get`, and `set` when settable) via
@@ -342,7 +406,8 @@ internal struct JSProperty {
       getEncode = "return \(callee).\(swiftName).toJavaScriptValue(in: runtime)"
     }
     lines.append(
-      accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getEncode)"))
+      accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getEncode)")
+    )
 
     // Setter: decode argument 0 by the static type through `decode` and write `<callee>.<name>`. A
     // typed setter needs a known value type; when the type couldn't be inferred the property is bound
@@ -353,12 +418,19 @@ internal struct JSProperty {
       let setDecode = "\(callee).\(swiftName) = try \(decode)"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, returnsVoid: true, body: "\(unwrap)\(setDecode)"))
+          descriptorName,
+          "set",
+          receiver: receiver,
+          returnsVoid: true,
+          body: "\(unwrap)\(setDecode)"
+        )
+      )
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { "  " + $0 }
       .joined(separator: "\n")
@@ -369,12 +441,17 @@ internal struct JSProperty {
   /// A setter passes `returnsVoid`, so its closure declares `-> Void` and binds through the `Void`
   /// overload, like a function that returns nothing.
   private func accessorClosure(
-    _ descriptorName: String, _ key: String, receiver: Receiver, returnsVoid: Bool = false, body: String
+    _ descriptorName: String,
+    _ key: String,
+    receiver: Receiver,
+    returnsVoid: Bool = false,
+    body: String
   ) -> String {
     let captures = receiver.captureClause
     // Indent each line of a (possibly multi-line) body to sit one level inside the closure; a bare
     // `\(body)` interpolation would only indent the first line.
-    let indentedBody = body
+    let indentedBody =
+      body
       .split(separator: "\n", omittingEmptySubsequences: false)
       .map { "  \($0)" }
       .joined(separator: "\n")
@@ -399,7 +476,10 @@ internal struct JSProperty {
 /// how each binding reaches its Swift value (module `self`, shared-object instance `_self`, or the
 /// metatype for a static member).
 private func decorateBody(
-  functions: [JSFunction], properties: [JSProperty], object: String, receiver: Receiver
+  functions: [JSFunction],
+  properties: [JSProperty],
+  object: String,
+  receiver: Receiver
 ) -> String {
   let functionBody = functions.map { $0.decorateStatements(object: object, receiver: receiver) }
   let propertyBody = properties.map { $0.decorateStatements(object: object, receiver: receiver) }
@@ -416,7 +496,11 @@ private func decorateBody(
 /// receiver; the shared-object counterpart is `buildDecorateSharedObjectPhase`.
 internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties: [JSProperty]) -> DeclSyntax {
   let body = decorateBody(
-    functions: functions, properties: properties, object: Phase.object.rawValue, receiver: .module)
+    functions: functions,
+    properties: properties,
+    object: Phase.object.rawValue,
+    receiver: .module
+  )
   return """
     @JavaScriptActor
     public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
@@ -437,13 +521,21 @@ internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties:
 /// which builds an instance and is emitted separately (see `JSConstructor.buildConstructor`). Each phase
 /// is emitted only when the type has a member for it.
 internal func buildDecorateSharedObjectPhase(
-  phase: Phase, functions: [JSFunction], properties: [JSProperty], typeName: String
+  phase: Phase,
+  functions: [JSFunction],
+  properties: [JSProperty],
+  typeName: String
 ) -> DeclSyntax {
-  let receiver: Receiver = phase == .constructor
+  let receiver: Receiver =
+    phase == .constructor
     ? .staticMember(typeName: typeName)
     : .sharedObject(typeName: typeName)
   let body = decorateBody(
-    functions: functions, properties: properties, object: phase.rawValue, receiver: receiver)
+    functions: functions,
+    properties: properties,
+    object: phase.rawValue,
+    receiver: receiver
+  )
   return """
     @JavaScriptActor
     public override class func _decorateSharedObject(\(raw: phase.rawValue): borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -54,7 +54,8 @@ public struct EventMacro: AccessorMacro {
     // through the getter, so the body never has to spell the payload type. A sync event calls
     // `emitSync` (inline dispatch, JS thread only); the default calls the scheduling `emit`.
     let emitMethod = event.isSync ? "emitSync" : "emit"
-    let closure = event.hasPayload
+    let closure =
+      event.hasPayload
       ? "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload) }"
       : "{ [weak self] in self?.\(emitMethod)(event: \"\(event.jsName)\") }"
     return [
@@ -85,9 +86,10 @@ extension EventMacro: PeerMacro {
     // and asserting the enclosing type by its spelled name so the conformance error names the
     // user's type rather than 'Self'.
     let name = event.swiftName
-    let payload = event.payloadType.flatMap(assertableBoundaryType)
+    let payload = event.payloadType.flatMap { assertableBoundaryType($0, constraint: jsConvertibleProtocolName) }
     let owner = enclosingTypeName(in: context) ?? "Self"
-    let helper = payload != nil
+    let helper =
+      payload != nil
       ? "func \(name)<P: \(jsConvertibleProtocolName), E: \(eventEmitterProtocolName)>(_: P.Type, _: E.Type) {}"
       : "func \(name)<E: \(eventEmitterProtocolName)>(_: E.Type) {}"
     let call = payload.map { "\(name)(\($0).self, \(owner).self)" } ?? "\(name)(\(owner).self)"
@@ -132,7 +134,8 @@ private func validatedEvent(
   }
   if varDecl.attributes.firstAttribute(named: "JS") != nil {
     throw MacroExpansionErrorMessage(
-      "@Event and @JS cannot be combined on the same property; an event is exposed to JS on its own, so remove one of the attributes")
+      "@Event and @JS cannot be combined on the same property; an event is exposed to JS on its own, so remove one of the attributes"
+    )
   }
   // The compiler also rejects accessor macros on a `let`, but with a generic message; this one says
   // what to do instead and carries the fix-it doing it. The synthesized property is getter-only, so
@@ -142,32 +145,40 @@ private func validatedEvent(
   }
   if varDecl.modifiers.contains(where: isTypeLevelModifier) {
     throw MacroExpansionErrorMessage(
-      "@Event must be an instance property; events are emitted from a module or shared object instance.")
+      "@Event must be an instance property; events are emitted from a module or shared object instance."
+    )
   }
   guard varDecl.bindings.count == 1, let binding = varDecl.bindings.first,
-    let identifier = binding.pattern.as(IdentifierPatternSyntax.self) else {
+    let identifier = binding.pattern.as(IdentifierPatternSyntax.self)
+  else {
     throw MacroExpansionErrorMessage(
-      "@Event must be applied to a single named property; declare each event separately")
+      "@Event must be applied to a single named property; declare each event separately"
+    )
   }
   if binding.initializer != nil {
     throw MacroExpansionErrorMessage(
-      "@Event property cannot have an initial value; the macro synthesizes the closure")
+      "@Event property cannot have an initial value; the macro synthesizes the closure"
+    )
   }
   if binding.accessorBlock != nil {
     throw MacroExpansionErrorMessage(
-      "@Event property cannot declare its own accessors; the macro synthesizes the getter")
+      "@Event property cannot declare its own accessors; the macro synthesizes the getter"
+    )
   }
   guard let functionType = underlyingFunctionType(of: binding.typeAnnotation?.type) else {
     throw MacroExpansionErrorMessage(
-      "@Event property must declare a function type, such as '(Payload) -> Void' or '() -> Void'")
+      "@Event property must declare a function type, such as '(Payload) -> Void' or '() -> Void'"
+    )
   }
   guard isVoidReturn(functionType.returnClause.type) else {
     throw MacroExpansionErrorMessage(
-      "@Event function type must return 'Void'; an event dispatches to JS and has no return value")
+      "@Event function type must return 'Void'; an event dispatches to JS and has no return value"
+    )
   }
   guard functionType.parameters.count <= 1 else {
     throw MacroExpansionErrorMessage(
-      "@Event function type takes at most one payload parameter; combine multiple values into a single record")
+      "@Event function type takes at most one payload parameter; combine multiple values into a single record"
+    )
   }
   // The payload is encoded to JavaScript, and a native closure can't be encoded.
   if let payloadClosure = functionType.parameters.first.flatMap({ firstFunctionType(in: $0.type) }) {
@@ -177,7 +188,8 @@ private func validatedEvent(
         message: EventDiagnosticMessage(
           "@Event payload can't hold a closure: the payload is encoded to JavaScript, and a native closure can't be encoded.",
           id: "event-closure-payload"
-        ))
+        )
+      )
     ])
   }
 
@@ -321,7 +333,8 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
     return underlyingFunctionType(of: attributed.baseType)
   }
   if let tuple = type.as(TupleTypeSyntax.self),
-    tuple.elements.count == 1, let element = tuple.elements.first, element.firstName == nil {
+    tuple.elements.count == 1, let element = tuple.elements.first, element.firstName == nil
+  {
     return underlyingFunctionType(of: element.type)
   }
   return type.as(FunctionTypeSyntax.self)
@@ -334,7 +347,8 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
 private func isVoidReturn(_ type: TypeSyntax) -> Bool {
   // Peel single-element, unlabeled parentheses: `(Void)` and `(())` are the same type as their content.
   if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1,
-    let element = tuple.elements.first, element.firstName == nil {
+    let element = tuple.elements.first, element.firstName == nil
+  {
     return isVoidReturn(element.type)
   }
   let text = type.trimmedDescription