expo-modules-macros 0.20.0 → 0.22.0

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -2,34 +2,32 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
-/**
- Macro applied to a module class. It plays three roles, each implemented in its own
- extension below:
-
- - `MemberMacro`: binds `@JS`-marked members directly into the module's JS object via the
-   synthesized `_decorateModule`, and emits the resolved module name as a non-optional
-   `_jsName` static (no `Name(…)` DSL element). It also synthesizes a
-   framework-internal `_synthesizedDefinition()` returning `[AnyDefinition]` (now carrying
-   only nested `classes` entries) that `expo-modules-core` merges into the module's
-   definition. When the class doesn't already inherit `Module`/`BaseModule`, it also
-   synthesizes the `appContext` storage and `init(appContext:)` those base classes provide.
- - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
-   `@ModuleDefinitionBuilder` on a `definition()` method.
- - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
-
- Inheriting from `Module` is therefore optional — a class can carry any superclass (or
- none) and still be a module, because everything inheritance used to provide is synthesized.
-
-   @ExpoModule
-   public final class MyModule {
-     public func definition() -> ModuleDefinition {
-       Name("MyModule")
-     }
-
-     @JS
-     func greet(name: String) -> String { "Hi, \(name)" }
-   }
- */
+/// Macro applied to a module class. It plays three roles, each implemented in its own
+/// extension below:
+///
+/// - `MemberMacro`: binds `@JS`-marked members directly into the module's JS object via the
+///   synthesized `_decorateModule`, and emits the resolved module name as a non-optional
+///   `_jsName` static (no `Name(…)` DSL element). It also synthesizes a
+///   framework-internal `_synthesizedDefinition()` returning `[AnyDefinition]` (now carrying
+///   only nested `classes` entries) that `expo-modules-core` merges into the module's
+///   definition. When the class doesn't already inherit `Module`/`BaseModule`, it also
+///   synthesizes the `appContext` storage and `init(appContext:)` those base classes provide.
+/// - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
+///   `@ModuleDefinitionBuilder` on a `definition()` method.
+/// - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
+///
+/// Inheriting from `Module` is therefore optional — a class can carry any superclass (or
+/// none) and still be a module, because everything inheritance used to provide is synthesized.
+///
+///   @ExpoModule
+///   public final class MyModule {
+///     public func definition() -> ModuleDefinition {
+///       Name("MyModule")
+///     }
+///
+///     @JS
+///     func greet(name: String) -> String { "Hi, \(name)" }
+///   }
 public struct ExpoModuleMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
@@ -62,17 +60,25 @@ public struct ExpoModuleMacro: MemberMacro {
       let decl = member.decl
 
       if let funcDecl = decl.as(FunctionDeclSyntax.self),
-        let attribute = funcDecl.attributes.firstAttribute(named: "JS") {
-        functions.append(JSFunction(funcDecl: funcDecl, attribute: attribute))
+        let attribute = funcDecl.attributes.firstAttribute(named: "JS")
+      {
+        let function = JSFunction(funcDecl: funcDecl, attribute: attribute)
+        functions.append(function)
+        if let variant = function.asyncVariant {
+          functions.append(variant)
+        }
         continue
       }
 
       if let varDecl = decl.as(VariableDeclSyntax.self),
-        let attribute = varDecl.attributes.firstAttribute(named: "JS") {
+        let attribute = varDecl.attributes.firstAttribute(named: "JS")
+      {
         properties.append(contentsOf: collectProperties(varDecl: varDecl, attribute: attribute))
       }
     }
 
+    diagnoseJSNameCollisions(functions: functions, properties: properties, in: context)
+
     let body: String
     if entries.isEmpty {
       body = "  return []"
@@ -152,12 +158,14 @@ extension ExpoModuleMacro: MemberAttributeMacro {
 
     // `@JS` sync members run on the JS thread; stamp `@JavaScriptActor` so isolation is
     // checked at compile time. Skipped when the member already chose an isolation
-    // (`async`, `nonisolated`, or another global actor) — see `shouldStampJavaScriptActor`.
+    // (`nonisolated` or another global actor), or when `.concurrent` or `.withAsync("name")` runs
+    // it on the concurrent pool. See `shouldStampJavaScriptActor`.
     // `@Event(sync: true)` members get the stamp too: a sync event dispatches inline, so the
     // isolation forces its call site onto the JS thread. Async events (the default) are
     // deliberately left unstamped — their `emit` schedules onto the JS thread itself.
     if memberHasJSAttribute(member) || isSyncEventMember(member),
-      shouldStampJavaScriptActor(on: member, enclosedBy: declaration) {
+      shouldStampJavaScriptActor(on: member, enclosedBy: declaration)
+    {
       attributes.append("@JavaScriptActor")
     }
 
@@ -172,7 +180,8 @@ extension ExpoModuleMacro: MemberAttributeMacro {
     // they already wrote `@ModuleDefinitionBuilder` themselves, which would otherwise be
     // a duplicate attribute.
     if isModuleDefinitionFunction(member),
-      !memberAttributes(of: member).contains(where: { hasAttributeName($0, "ModuleDefinitionBuilder") }) {
+      !memberAttributes(of: member).contains(where: { hasAttributeName($0, "ModuleDefinitionBuilder") })
+    {
       attributes.append("@ModuleDefinitionBuilder")
     }
 
@@ -184,7 +193,8 @@ private func isModuleDefinitionFunction(_ member: some DeclSyntaxProtocol) -> Bo
   guard let funcDecl = member.as(FunctionDeclSyntax.self),
     funcDecl.name.text == "definition",
     funcDecl.signature.parameterClause.parameters.isEmpty,
-    let returnType = funcDecl.signature.returnClause?.type else {
+    let returnType = funcDecl.signature.returnClause?.type
+  else {
     return false
   }
   return baseIdentifier(of: returnType) == "ModuleDefinition"
@@ -213,7 +223,8 @@ extension ExpoModuleMacro: ExtensionMacro {
     // These base types already supply `AnyModule`; emitting a second conformance here
     // would be redundant and error.
     if let classDecl = declaration.as(ClassDeclSyntax.self),
-      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"]) {
+      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"])
+    {
       return []
     }
     let conformance: DeclSyntax = "extension \(type.trimmed): AnyModule {}"
@@ -230,7 +241,8 @@ private func hasStoredProperty(_ classDecl: ClassDeclSyntax, named name: String)
     }
     for binding in varDecl.bindings {
       if let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
-        identifier.identifier.text == name {
+        identifier.identifier.text == name
+      {
         return true
       }
     }
@@ -238,14 +250,12 @@ private func hasStoredProperty(_ classDecl: ClassDeclSyntax, named name: String)
   return false
 }
 
-/**
- True if the class declares an initializer that satisfies the `init(appContext:)` protocol
- requirement: a single parameter labeled `appContext` whose type is written as `AppContext`
- (or `…​.AppContext`). Both must match — the label is part of the requirement, so
- `init(c: AppContext)` does *not* satisfy it (we still synthesize ours), and the type guards
- against a same-labeled init of an unrelated type. A macro can't resolve types, so this is a
- syntactic match on the spelled name.
- */
+/// True if the class declares an initializer that satisfies the `init(appContext:)` protocol
+/// requirement: a single parameter labeled `appContext` whose type is written as `AppContext`
+/// (or `…​.AppContext`). Both must match — the label is part of the requirement, so
+/// `init(c: AppContext)` does *not* satisfy it (we still synthesize ours), and the type guards
+/// against a same-labeled init of an unrelated type. A macro can't resolve types, so this is a
+/// syntactic match on the spelled name.
 private func hasAppContextInitializer(_ classDecl: ClassDeclSyntax) -> Bool {
   for member in classDecl.memberBlock.members {
     guard let initDecl = member.decl.as(InitializerDeclSyntax.self) else {

package/apple/Sources/ExpoModulesMacros/ExpoModulesOptimizedMacro.swift

@@ -34,7 +34,8 @@ public struct OptimizedFunctionAttachedMacro: PeerMacro {
   ) throws -> [DeclSyntax] {
     guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
       throw MacroExpansionErrorMessage(
-        "@OptimizedFunction can only be attached to function declarations")
+        "@OptimizedFunction can only be attached to function declarations"
+      )
     }
 
     let functionName = funcDecl.name.text

package/apple/Sources/ExpoModulesMacros/FreeFormTypes.swift

@@ -178,72 +178,13 @@ internal func isAnyType(_ type: some SyntaxProtocol) -> Bool {
   if let member = type.as(MemberTypeSyntax.self),
     member.name.text == "Any",
     member.genericArgumentClause == nil,
-    let base = member.baseType.as(IdentifierTypeSyntax.self) {
+    let base = member.baseType.as(IdentifierTypeSyntax.self)
+  {
     return base.name.text == "Swift"
   }
   return false
 }
 
-/// The element type of `[T]` or `Array<T>`, or `nil` for any other type.
-private func arrayElementType(_ type: TypeSyntax) -> TypeSyntax? {
-  if let array = type.as(ArrayTypeSyntax.self) {
-    return array.element
-  }
-  guard let arguments = genericArguments(of: type, named: "Array"), arguments.count == 1 else {
-    return nil
-  }
-  return arguments[0]
-}
-
-/// The value type of `[String: V]` or `Dictionary<String, V>`, or `nil` for any other type, including a
-/// dictionary with a different key type.
-private func stringKeyedDictionaryValueType(_ type: TypeSyntax) -> TypeSyntax? {
-  if let dictionary = type.as(DictionaryTypeSyntax.self) {
-    return isStringType(dictionary.key) ? dictionary.value : nil
-  }
-  guard let arguments = genericArguments(of: type, named: "Dictionary"), arguments.count == 2 else {
-    return nil
-  }
-  return isStringType(arguments[0]) ? arguments[1] : nil
-}
-
-/// The type arguments of a generic type spelled `<name><…>` (or `Swift.<name><…>`), or `nil` when the
-/// type has another name or no type arguments.
-private func genericArguments(of type: TypeSyntax, named name: String) -> [TypeSyntax]? {
-  let clause: GenericArgumentClauseSyntax?
-  if let identifier = type.as(IdentifierTypeSyntax.self), identifier.name.text == name {
-    clause = identifier.genericArgumentClause
-  } else if let member = type.as(MemberTypeSyntax.self),
-    member.name.text == name,
-    member.baseType.as(IdentifierTypeSyntax.self)?.name.text == "Swift" {
-    clause = member.genericArgumentClause
-  } else {
-    return nil
-  }
-  guard let clause else {
-    return nil
-  }
-  var types: [TypeSyntax] = []
-  for argument in clause.arguments {
-    guard case .type(let type) = argument.argument else {
-      return nil
-    }
-    types.append(type)
-  }
-  return types
-}
-
-/// True when the type is `String` or `Swift.String`.
-private func isStringType(_ type: TypeSyntax) -> Bool {
-  if let identifier = type.as(IdentifierTypeSyntax.self) {
-    return identifier.name.text == "String" && identifier.genericArgumentClause == nil
-  }
-  if let member = type.as(MemberTypeSyntax.self), member.name.text == "String" {
-    return member.baseType.as(IdentifierTypeSyntax.self)?.name.text == "Swift"
-  }
-  return false
-}
-
 /// Walks a type looking for `Any` (or `Swift.Any`) anywhere inside it.
 private final class AnyTypeFinder: SyntaxVisitor {
   var found = false

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -23,7 +23,8 @@ internal struct JSConstructor {
       guard arguments.count == \(parameters.count) else {
         throw Exceptions.ArgumentsRangeMismatch((functionName: "\(typeName)", received: arguments.count, required: \(parameters.count), maximum: \(parameters.count)))
       }
-      """)
+      """
+    )
 
     var callArguments: [String] = []
     for (index, parameter) in parameters.enumerated() {
@@ -32,7 +33,8 @@ internal struct JSConstructor {
           type: parameter.type,
           into: "arg\(index)",
           from: "arguments.unownedValue(at: \(index))"
-        ))
+        )
+      )
 
       let label = parameter.firstName.text
       callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")
@@ -40,7 +42,8 @@ internal struct JSConstructor {
 
     lines.append("return \(typeName)(\(callArguments.joined(separator: ", ")))")
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { indent + $0 }
       .joined(separator: "\n")

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -35,6 +35,7 @@ public struct JSMacro: PeerMacro {
     diagnoseFreeFormTypes(in: declaration, in: context)
     diagnoseClosureTypes(in: declaration, in: context)
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
+    diagnoseAsyncVariantOption(of: node, on: declaration, in: context)
 
     guard let member = boundaryMember(of: declaration),
       let assertion = directionalConformanceAssertion(
@@ -43,7 +44,8 @@ public struct JSMacro: PeerMacro {
         encodableType: member.encodableType,
         callbackArgumentTypes: member.callbackArgumentTypes,
         isStatic: member.isStatic
-      ) else {
+      )
+    else {
       return []
     }
     return [assertion]
@@ -74,7 +76,9 @@ private func diagnoseConcurrentOption(
           id: "js-concurrent-requires-async",
           severity: .error
         ),
-        fixIts: [insertAsyncFixIt(for: funcDecl)]))
+        fixIts: [insertAsyncFixIt(for: funcDecl)]
+      )
+    )
     return
   }
   context.diagnose(
@@ -84,7 +88,108 @@ private func diagnoseConcurrentOption(
         "'.concurrent' applies only to an 'async' @JS function, not to a property or initializer.",
         id: "js-concurrent-requires-function",
         severity: .error
-      )))
+      )
+    )
+  )
+}
+
+/// Emits the diagnostics for `@JS(.withAsync("name"))` on a member that can't take it. The option
+/// adds a promise-returning variant that calls the function on the concurrent pool, so it needs a
+/// synchronous function without a global actor, and the variant's JavaScript name as a string literal.
+private func diagnoseAsyncVariantOption(
+  of node: AttributeSyntax,
+  on declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  guard let option = asyncVariantOption(of: node) else {
+    return
+  }
+  guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "'.withAsync' applies only to a synchronous @JS function, not to a property or initializer.",
+          id: "js-async-variant-requires-function",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  if funcDecl.signature.effectSpecifiers?.asyncSpecifier != nil {
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "'.withAsync' adds a promise-returning variant to a synchronous function, and this function is already 'async'. Remove '.withAsync', and use '.concurrent' to run the function off the JavaScript thread.",
+          id: "js-async-variant-on-async-function",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  for duplicate in asyncVariantOptions(of: node).dropFirst() {
+    context.diagnose(
+      Diagnostic(
+        node: duplicate,
+        message: JSDiagnosticMessage(
+          "'.withAsync' can be listed only once: a function gets one promise-returning variant.",
+          id: "js-async-variant-duplicate",
+          severity: .error
+        )
+      )
+    )
+  }
+  if asyncVariantName(of: option) == nil {
+    context.diagnose(
+      Diagnostic(
+        node: option,
+        message: JSDiagnosticMessage(
+          "'.withAsync' takes the JavaScript name of the variant as a string literal, for example '.withAsync(\"loadAsync\")'.",
+          id: "js-async-variant-name",
+          severity: .error
+        )
+      )
+    )
+  }
+  if let isolation = globalActorIsolation(of: funcDecl, in: context) {
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          isolation.enclosingTypeName.map {
+            "'.withAsync' calls the function on the concurrent thread pool, so the function can't inherit '\(isolation.attribute)' from '\($0)'. Mark the function 'nonisolated'."
+          }
+            ?? "'.withAsync' calls the function on the concurrent thread pool, so the function can't be isolated to '\(isolation.attribute)'.",
+          id: "js-async-variant-isolated",
+          severity: .error
+        )
+      )
+    )
+  }
+}
+
+/// The global actor a function is isolated to, written on the function itself or inherited from its
+/// enclosing type, or `nil` when it has none or is `nonisolated`. `enclosingTypeName` is set when the
+/// isolation is inherited.
+private func globalActorIsolation(
+  of funcDecl: FunctionDeclSyntax,
+  in context: some MacroExpansionContext
+) -> (attribute: String, enclosingTypeName: String?)? {
+  if let attribute = funcDecl.attributes.first(where: hasGlobalActorShape) {
+    return (attribute.trimmedDescription, nil)
+  }
+  if funcDecl.modifiers.contains(where: { $0.name.text == "nonisolated" }) {
+    return nil
+  }
+  guard let enclosing = context.lexicalContext.first,
+    let attribute = enclosing.asProtocol(WithAttributesSyntax.self)?.attributes.first(where: hasGlobalActorShape)
+  else {
+    return nil
+  }
+  return (attribute.trimmedDescription, enclosing.asProtocol(NamedDeclSyntax.self)?.name.text)
 }
 
 /// The fix-it offered alongside the synchronous-function diagnostic: insert `async` into the
@@ -144,7 +249,9 @@ private func diagnoseParameterSpecifiers(
           "A @JS parameter can't be '\(specifier)': its argument is a value decoded from JavaScript, which can't be written back or carry an isolation.",
           id: "js-parameter-specifier",
           severity: .error
-        )))
+        )
+      )
+    )
   }
 }
 
@@ -173,14 +280,16 @@ private func diagnoseFreeFormTypes(
     // A constructor decodes its arguments exactly like a function and has no return value.
     types = initDecl.signature.parameterClause.parameters.map { SpecifiedType($0.type).type }
   } else if let varDecl = declaration.as(VariableDeclSyntax.self),
-    let type = varDecl.bindings.first?.typeAnnotation?.type {
+    let type = varDecl.bindings.first?.typeAnnotation?.type
+  {
     types = [type]
   }
 
   for type in types
   where mentionsFreeFormAny(type) && !isConvertibleFreeFormType(type) && !containsFunctionType(type) {
     context.diagnose(
-      Diagnostic(node: type, message: unconvertibleFreeFormError(for: type.trimmedDescription)))
+      Diagnostic(node: type, message: unconvertibleFreeFormError(for: type.trimmedDescription))
+    )
   }
 }
 
@@ -234,61 +343,49 @@ private struct BoundaryMember {
 
 /// Reads the boundary member off a `@JS` declaration, splitting its types by conversion direction. A
 /// function contributes its parameter types (decodable) and its return type when non-Void (encodable);
-/// a property contributes its value type as encodable (the getter) and also as decodable when settable
-/// (the setter). Composed types (`[Int]`, `String?`, …) are kept verbatim, their conditional
-/// conformances transitively constraining the elements. A type that mentions `Any` is left out: it
-/// converts through the free-form methods, or is diagnosed by `diagnoseFreeFormTypes`. Returns `nil`
-/// for declaration kinds `@JS` doesn't read types from, a property whose type isn't spelled out (a
-/// syntactic macro can't recover it), or one whose type mentions `Any`.
+/// an initializer contributes its parameter types; a property contributes its value type as encodable
+/// (the getter) and also as decodable when settable (the setter). Composed types (`[Int]`, `String?`,
+/// …) are kept verbatim, their conditional conformances transitively constraining the elements. A type
+/// that mentions `Any` is left out: it converts through the free-form methods, or is diagnosed by
+/// `diagnoseFreeFormTypes`. Returns `nil` for declaration kinds `@JS` doesn't read types from, a
+/// property whose type isn't spelled out (a syntactic macro can't recover it), or one whose type
+/// mentions `Any`.
 private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> BoundaryMember? {
   if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
-    // A closure argument moves data the other way: JS receives its parameters and returns its result.
-    // A closure in any other position is diagnosed by `diagnoseClosureTypes` and left out here, since
-    // its metatype isn't a valid expression in the assertion.
-    var decodableTypes: [String] = []
-    var callbackArgumentTypes: [String] = []
-    for parameter in funcDecl.signature.parameterClause.parameters {
-      // The specifier isn't part of the asserted type, and a parameter with one the binding can't honor
-      // is reported by `diagnoseParameterSpecifiers` and not asserted.
-      let specified = SpecifiedType(parameter.type)
-      guard specified.unsupportedSpecifier == nil else {
-        continue
-      }
-      guard let closure = JSClosureType(specified.type) else {
-        if !containsFunctionType(specified.type) && !mentionsFreeFormAny(specified.type) {
-          decodableTypes.append(specified.type.trimmedDescription)
-        }
-        continue
-      }
-      // A closure type that mentions `Any` is reported by `diagnoseClosureTypes` instead.
-      for parameter in closure.parameters
-      where !containsFunctionType(parameter.type) && !mentionsFreeFormAny(parameter.type) {
-        callbackArgumentTypes.append(parameter.type.trimmedDescription)
-      }
-      let closureReturnType = closure.functionType.returnClause.type
-      if let returnType = closure.returnType,
-        !containsFunctionType(closureReturnType) && !mentionsFreeFormAny(closureReturnType) {
-        decodableTypes.append(returnType)
-      }
-    }
+    let argumentTypes = argumentBoundaryTypes(of: funcDecl.signature.parameterClause.parameters)
     let returnType = funcDecl.signature.returnClause?.type
     let encodableType = returnType.flatMap {
       isVoidType($0) || containsFunctionType($0) || mentionsFreeFormAny($0) ? nil : $0.trimmedDescription
     }
     return BoundaryMember(
       name: funcDecl.name.text,
-      decodableTypes: decodableTypes,
+      decodableTypes: argumentTypes.decodable,
       encodableType: encodableType,
-      callbackArgumentTypes: callbackArgumentTypes,
+      callbackArgumentTypes: argumentTypes.callbackArguments,
       isStatic: isTypeLevel(funcDecl.modifiers)
     )
   }
 
+  if let initDecl = declaration.as(InitializerDeclSyntax.self) {
+    // A constructor decodes its arguments like a function does, and the instance it returns isn't
+    // encoded. The name is escaped because it also names the assertion's nested helper, and `init` is
+    // a keyword.
+    let argumentTypes = argumentBoundaryTypes(of: initDecl.signature.parameterClause.parameters)
+    return BoundaryMember(
+      name: "`init`",
+      decodableTypes: argumentTypes.decodable,
+      encodableType: nil,
+      callbackArgumentTypes: argumentTypes.callbackArguments,
+      isStatic: false
+    )
+  }
+
   if let varDecl = declaration.as(VariableDeclSyntax.self),
     let binding = varDecl.bindings.first,
     let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
     let type = binding.typeAnnotation?.type,
-    !containsFunctionType(type) {
+    !containsFunctionType(type)
+  {
     // A `let`, or a `var` with no setter, is read-only (encodable only). A settable `var` is also
     // decoded on write, so its value type is asserted in both directions. A type that mentions `Any`
     // converts through the free-form methods instead, so it isn't asserted at all.
@@ -309,6 +406,45 @@ private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> Boundary
   return nil
 }
 
+/// The boundary types of a function's or constructor's arguments: an argument is decoded from JS, and
+/// a closure argument instead contributes its parameter types (encoded when native code calls it) and
+/// its return type (decoded).
+private func argumentBoundaryTypes(
+  of parameters: FunctionParameterListSyntax
+) -> (decodable: [String], callbackArguments: [String]) {
+  // A closure argument moves data the other way: JS receives its parameters and returns its result.
+  // A closure in any other position is diagnosed by `diagnoseClosureTypes` and left out here, since
+  // its metatype isn't a valid expression in the assertion.
+  var decodableTypes: [String] = []
+  var callbackArgumentTypes: [String] = []
+  for parameter in parameters {
+    // The specifier isn't part of the asserted type, and a parameter with one the binding can't honor
+    // is reported by `diagnoseParameterSpecifiers` and not asserted.
+    let specified = SpecifiedType(parameter.type)
+    guard specified.unsupportedSpecifier == nil else {
+      continue
+    }
+    guard let closure = JSClosureType(specified.type) else {
+      if !containsFunctionType(specified.type) && !mentionsFreeFormAny(specified.type) {
+        decodableTypes.append(specified.type.trimmedDescription)
+      }
+      continue
+    }
+    // A closure type that mentions `Any` is reported by `diagnoseClosureTypes` instead.
+    for parameter in closure.parameters
+    where !containsFunctionType(parameter.type) && !mentionsFreeFormAny(parameter.type) {
+      callbackArgumentTypes.append(parameter.type.trimmedDescription)
+    }
+    let closureReturnType = closure.functionType.returnClause.type
+    if let returnType = closure.returnType,
+      !containsFunctionType(closureReturnType) && !mentionsFreeFormAny(closureReturnType)
+    {
+      decodableTypes.append(returnType)
+    }
+  }
+  return (decodableTypes, callbackArgumentTypes)
+}
+
 /// True when a return clause is written as `Void` / `()` — nothing crosses the boundary, so it needs
 /// no conformance assertion. (A missing return clause never reaches here: `returnClause` is `nil`.)
 private func isVoidType(_ type: TypeSyntax) -> Bool {