expo-modules-macros 0.26.0 → 0.27.1

package/apple/Sources/ExpoModulesMacros/Expand/MacroExpander.swift

@@ -0,0 +1,484 @@
+import ExpoModulesCLI
+import SwiftBasicFormat
+import SwiftDiagnostics
+import SwiftParser
+import SwiftParserDiagnostics
+import SwiftSyntax
+import SwiftSyntaxMacroExpansion
+import SwiftSyntaxMacros
+
+/// Expands the macros of the plugin in one source file in process, with the same swift-syntax
+/// machinery as `assertMacroExpansion`. The macros only read the syntax tree, so the generated code
+/// is what the compiler gets, except for the names from `makeUniqueName`. The compiler also skips the
+/// extension conformances that a type already has; the macros check the inheritance clause for that
+/// too, so the result differs only when a conformance is inherited from somewhere else.
+///
+/// Without `symbols`, it returns one expansion of the whole file. Otherwise it returns one expansion
+/// for each symbol declared in the file, and only the diagnostics inside those declarations:
+///
+/// - A type (`MyModule`, `MyModule.Options`): the expanded type and the extensions that its macros
+///   add.
+/// - A member (`MyModule.greet`, `MyModule.init`): the expanded type that declares it, with only the
+///   declarations of that name (all overloads). The member macros of the type then generate only the
+///   code for that member. A macro that reads other members (for example to find a name collision)
+///   can generate a little differently than for the whole type.
+///
+/// A symbol that the file doesn't declare is left out of the expansions.
+public func expandMacros(source: String, file: String, symbols: [String]) -> ExpandedFile {
+  let tree = Parser.parse(source: source)
+  let converter = SourceLocationConverter(fileName: file, tree: tree)
+  let (expanded, context) = expand(tree, file: file)
+
+  var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: tree).map { diagnostic in
+    expansionDiagnostic(diagnostic) { position, _ in converter.location(for: position) }
+  }
+  let originalDeclarations = OriginalDeclarations(tree)
+  diagnostics += context.diagnostics.map { diagnostic in
+    expansionDiagnostic(diagnostic) { position, node in
+      let location = context.location(for: position, anchoredAt: node, fileName: file)
+      if let original = originalDeclarations.position(of: position, in: node, shiftedOffset: location.offset) {
+        return converter.location(for: original)
+      }
+      return location
+    }
+  }
+  diagnostics.sort { ($0.line, $0.column) < ($1.line, $1.column) }
+
+  guard !symbols.isEmpty else {
+    return ExpandedFile(
+      file: file,
+      expansions: [Expansion(symbol: nil, source: expanded.description)],
+      diagnostics: diagnostics
+    )
+  }
+
+  let declarations = SymbolIndex(tree).declarations
+  var expansions: [Expansion] = []
+  var lineRanges: [ClosedRange<Int>] = []
+  for symbol in symbols {
+    let types = declarations.filter { $0.path == symbol && $0.kind == .type }
+    let members = declarations.filter { $0.path == symbol && $0.kind == .member }
+
+    if !types.isEmpty {
+      let source = render(typePath: symbol, in: expanded, original: tree) { index in
+        index.filter { $0.path == symbol && $0.kind == .type }.map(\.node)
+      }
+      expansions.append(Expansion(symbol: symbol, source: source))
+      lineRanges += types.map { lineRange(of: $0.node, converter: converter) }
+    } else if !members.isEmpty {
+      let pruned = MemberPruner(
+        parents: Set(members.compactMap(\.parent?.id)),
+        kept: Set(members.map(\.node.id))
+      )
+      .rewrite(tree)
+      guard let prunedTree = pruned.as(SourceFileSyntax.self) else {
+        continue
+      }
+      let parentPath = String(symbol[..<(symbol.lastIndex(of: ".") ?? symbol.startIndex)])
+      let (prunedExpansion, _) = expand(prunedTree, file: file)
+      // Only the types or extensions that declare the member: another extension of the same type
+      // isn't pruned.
+      let source = render(typePath: parentPath, in: prunedExpansion, original: prunedTree) { index in
+        let parents = Set(index.filter { $0.path == symbol && $0.kind == .member }.compactMap(\.parent?.id))
+        return index.filter { parents.contains($0.node.id) }.map(\.node)
+      }
+      expansions.append(Expansion(symbol: symbol, source: source))
+      lineRanges += members.map { lineRange(of: $0.node, converter: converter) }
+    }
+  }
+
+  return ExpandedFile(
+    file: file,
+    expansions: expansions,
+    diagnostics: diagnostics.filter { diagnostic in
+      lineRanges.contains { $0.contains(diagnostic.line) }
+    }
+  )
+}
+
+/// Expands every macro of the plugin in `tree`.
+private func expand(
+  _ tree: SourceFileSyntax,
+  file: String
+) -> (expanded: Syntax, context: BasicMacroExpansionContext) {
+  let specs = Dictionary(
+    uniqueKeysWithValues: ProvidedMacro.all.map {
+      ($0.name, MacroSpec(type: $0.type, conformances: $0.conformances))
+    }
+  )
+  let context = BasicMacroExpansionContext(
+    sourceFiles: [tree: .init(moduleName: "ExpandedModule", fullFilePath: file)]
+  )
+  let expanded = tree.expand(
+    macroSpecs: specs,
+    contextGenerator: { node in
+      BasicMacroExpansionContext(sharingWith: context, lexicalContext: node.allMacroLexicalContexts())
+    },
+    // The generated code follows the indentation of the file.
+    indentationWidth: BasicFormat.inferIndentation(of: tree) ?? .spaces(2)
+  )
+  return (expanded, context)
+}
+
+/// The expanded declarations that `select` picks from the symbols of `expanded`, each without the
+/// indentation of its nesting, followed by the extensions that the extension macros add for the type
+/// at `typePath`.
+private func render(
+  typePath: String,
+  in expanded: Syntax,
+  original: SourceFileSyntax,
+  select: ([SymbolDeclaration]) -> [Syntax]
+) -> String {
+  let declarations = select(SymbolIndex(expanded).declarations)
+  // The macro system adds the extensions after the expanded statements of the file, with the type
+  // name as the macro got it (qualified for a nested type). So they are the last statements, after
+  // the extensions that already end the file.
+  let statements = expanded.as(SourceFileSyntax.self)?.statements ?? []
+  let addedCount =
+    trailingExtensions(of: statements).count - trailingExtensions(of: original.statements).count
+  let addedExtensions = trailingExtensions(of: statements).suffix(max(addedCount, 0)).filter {
+    $0.extendedType.trimmedDescription == typePath
+  }
+  let nodes = declarations + addedExtensions.map(Syntax.init)
+  return nodes.map(withoutNestingIndentation).joined(separator: "\n\n") + "\n"
+}
+
+/// The extensions at the end of `statements`, up to the last statement that isn't one.
+private func trailingExtensions(of statements: CodeBlockItemListSyntax) -> [ExtensionDeclSyntax] {
+  var extensions: [ExtensionDeclSyntax] = []
+  for item in statements.reversed() {
+    guard let extensionDecl = item.item.as(ExtensionDeclSyntax.self) else {
+      break
+    }
+    extensions.insert(extensionDecl, at: 0)
+  }
+  return extensions
+}
+
+/// The source of `node` without its leading trivia, and with the indentation of its first line
+/// removed from all the lines.
+private func withoutNestingIndentation(_ node: Syntax) -> String {
+  var indentation = ""
+  for piece in node.leadingTrivia.pieces {
+    switch piece {
+    case .newlines, .carriageReturns, .carriageReturnLineFeeds:
+      indentation = ""
+    case .spaces(let count):
+      indentation += String(repeating: " ", count: count)
+    case .tabs(let count):
+      indentation += String(repeating: "\t", count: count)
+    default:
+      break
+    }
+  }
+  let lines = node.trimmedDescription.split(separator: "\n", omittingEmptySubsequences: false)
+  return lines.enumerated().map { index, line in
+    index > 0 && line.hasPrefix(indentation) ? String(line.dropFirst(indentation.count)) : String(line)
+  }
+  .joined(separator: "\n")
+}
+
+/// The lines of `node` in the original file, from its attributes to its closing brace.
+private func lineRange(of node: Syntax, converter: SourceLocationConverter) -> ClosedRange<Int> {
+  let start = converter.location(for: node.positionAfterSkippingLeadingTrivia).line
+  let end = converter.location(for: node.endPositionBeforeTrailingTrivia).line
+  return start...end
+}
+
+private func expansionDiagnostic(
+  _ diagnostic: Diagnostic,
+  location: (AbsolutePosition, Syntax) -> SourceLocation
+) -> ExpansionDiagnostic {
+  let start = location(diagnostic.position, diagnostic.node)
+  return ExpansionDiagnostic(
+    severity: severity(diagnostic.diagMessage.severity),
+    message: diagnostic.message,
+    line: start.line,
+    column: start.column,
+    notes: diagnostic.notes.map { note in
+      let noteStart = location(note.position, note.node)
+      return ExpansionNote(message: note.message, line: noteStart.line, column: noteStart.column)
+    },
+    fixIts: diagnostic.fixIts.map(\.message.message)
+  )
+}
+
+private func severity(_ severity: DiagnosticSeverity) -> ExpansionDiagnostic.Severity {
+  switch severity {
+  case .error: .error
+  case .warning: .warning
+  case .note: .note
+  case .remark: .remark
+  }
+}
+
+// MARK: - Diagnostic locations
+
+/// Maps a position in a declaration that a macro got to the same position in the original file.
+///
+/// The macro system detaches the declaration that it passes to an attached macro and maps positions
+/// in it back to the declaration it detached it from. But a peer macro gets the declaration with the
+/// attributes that the member attribute macros of its type added, for example the `@JavaScriptActor`
+/// that `@ExpoModule` adds to a `@JS` function, and that declaration isn't in the original file. So
+/// every position after the added attributes is off by their length. A diagnostic in a parameter
+/// type of a `@JS` function would be on the next line.
+///
+/// The text from the keyword of the declaration (`func`, `var`, `init`) to its end is the same in
+/// both, so this finds the original declaration by that text and moves the position by the offset of
+/// the keyword. A position before the keyword, in the attributes or the modifiers, isn't mapped.
+private struct OriginalDeclarations {
+  /// The positions of the keywords of the declarations in the original file, in source order, by the
+  /// text from the keyword to the end of the declaration.
+  private let keywordPositions: [String: [AbsolutePosition]]
+
+  init(_ tree: SourceFileSyntax) {
+    let collector = DeclarationCollector(viewMode: .sourceAccurate)
+    collector.walk(tree)
+    var keywordPositions: [String: [AbsolutePosition]] = [:]
+    for declaration in collector.declarations {
+      guard let keyword = keywordToken(of: declaration) else {
+        continue
+      }
+      keywordPositions[textFromKeyword(keyword, of: declaration), default: []].append(
+        keyword.positionAfterSkippingLeadingTrivia
+      )
+    }
+    self.keywordPositions = keywordPositions
+  }
+
+  /// The position in the original file of `position` in `node`, or `nil` when `node` is in the
+  /// original file, isn't in a detached declaration, or is before its keyword.
+  ///
+  /// `shiftedOffset` is the offset that the macro system maps `position` to. The added attributes
+  /// only move it forward, so when declarations with the same text are in the file, the one it is
+  /// in is the last one that starts at or before that offset.
+  func position(of position: AbsolutePosition, in node: Syntax, shiftedOffset: Int) -> AbsolutePosition? {
+    guard !node.root.is(SourceFileSyntax.self),
+      let declaration = node.root.as(DeclSyntax.self),
+      let keyword = keywordToken(of: declaration),
+      position >= keyword.positionAfterSkippingLeadingTrivia,
+      let candidates = keywordPositions[textFromKeyword(keyword, of: declaration)]
+    else {
+      return nil
+    }
+    let offset = position.utf8Offset - keyword.positionAfterSkippingLeadingTrivia.utf8Offset
+    let shiftedKeyword = shiftedOffset - offset
+    guard let originalKeyword = candidates.last(where: { $0.utf8Offset <= shiftedKeyword }) ?? candidates.first
+    else {
+      return nil
+    }
+    return AbsolutePosition(utf8Offset: originalKeyword.utf8Offset + offset)
+  }
+}
+
+/// The first token of `declaration` after its attributes and modifiers, such as `func` or `var`.
+private func keywordToken(of declaration: DeclSyntax) -> TokenSyntax? {
+  for child in declaration.children(viewMode: .sourceAccurate)
+  where !child.is(AttributeListSyntax.self) && !child.is(DeclModifierListSyntax.self) {
+    if let token = child.firstToken(viewMode: .sourceAccurate) {
+      return token
+    }
+  }
+  return nil
+}
+
+/// The source text of `declaration` from `keyword` to its end, without the trailing trivia.
+private func textFromKeyword(_ keyword: TokenSyntax, of declaration: DeclSyntax) -> String {
+  let text = Array(declaration.description.utf8)
+  let start = keyword.positionAfterSkippingLeadingTrivia.utf8Offset - declaration.position.utf8Offset
+  let end = declaration.endPositionBeforeTrailingTrivia.utf8Offset - declaration.position.utf8Offset
+  return String(decoding: text[start..<end], as: UTF8.self)
+}
+
+/// Collects every declaration in a tree.
+private final class DeclarationCollector: SyntaxAnyVisitor {
+  private(set) var declarations: [DeclSyntax] = []
+
+  override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
+    if let declaration = node.as(DeclSyntax.self) {
+      declarations.append(declaration)
+    }
+    return .visitChildren
+  }
+}
+
+// MARK: - Symbols
+
+/// A declaration that `--symbol` can name.
+private struct SymbolDeclaration {
+  enum Kind {
+    case type
+    case `extension`
+    case member
+  }
+
+  /// The names from the outermost type to the declaration, joined with dots: `MyModule.greet`. An
+  /// extension has the path of the type it extends.
+  let path: String
+  let kind: Kind
+  let node: Syntax
+
+  /// For a member, the type or extension that declares it.
+  let parent: Syntax?
+}
+
+/// Collects the types, extensions and members in a tree, also those inside `#if` blocks. Function
+/// bodies are skipped, so a local type isn't a symbol.
+private final class SymbolIndex: SyntaxVisitor {
+  private(set) var declarations: [SymbolDeclaration] = []
+  private var scopes: [(path: String, node: Syntax)] = []
+
+  init(_ tree: some SyntaxProtocol) {
+    super.init(viewMode: .sourceAccurate)
+    walk(tree)
+  }
+
+  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
+    enterType(node, name: node.name)
+  }
+
+  override func visitPost(_ node: ClassDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
+    enterType(node, name: node.name)
+  }
+
+  override func visitPost(_ node: StructDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
+    enterType(node, name: node.name)
+  }
+
+  override func visitPost(_ node: EnumDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: ActorDeclSyntax) -> SyntaxVisitorContinueKind {
+    enterType(node, name: node.name)
+  }
+
+  override func visitPost(_ node: ActorDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
+    enterType(node, name: node.name)
+  }
+
+  override func visitPost(_ node: ProtocolDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
+    let path = qualified(node.extendedType.trimmedDescription)
+    declarations.append(SymbolDeclaration(path: path, kind: .extension, node: Syntax(node), parent: nil))
+    scopes.append((path, Syntax(node)))
+    return .visitChildren
+  }
+
+  override func visitPost(_ node: ExtensionDeclSyntax) {
+    scopes.removeLast()
+  }
+
+  override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind {
+    addMember(node, names: [node.name.text])
+  }
+
+  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
+    addMember(
+      node,
+      names: node.bindings.compactMap { $0.pattern.as(IdentifierPatternSyntax.self)?.identifier.text }
+    )
+  }
+
+  override func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind {
+    addMember(node, names: ["init"])
+  }
+
+  override func visit(_ node: SubscriptDeclSyntax) -> SyntaxVisitorContinueKind {
+    addMember(node, names: ["subscript"])
+  }
+
+  override func visit(_ node: EnumCaseDeclSyntax) -> SyntaxVisitorContinueKind {
+    addMember(node, names: node.elements.map(\.name.text))
+  }
+
+  private func enterType(_ node: some DeclSyntaxProtocol, name: TokenSyntax) -> SyntaxVisitorContinueKind {
+    let path = qualified(name.text)
+    declarations.append(SymbolDeclaration(path: path, kind: .type, node: Syntax(node), parent: nil))
+    scopes.append((path, Syntax(node)))
+    return .visitChildren
+  }
+
+  /// Records a member of the innermost type. Doesn't visit the children: a declaration in a body or
+  /// an accessor isn't a member.
+  private func addMember(_ node: some DeclSyntaxProtocol, names: [String]) -> SyntaxVisitorContinueKind {
+    if let scope = scopes.last {
+      for name in names.map(withoutBackticks) {
+        declarations.append(
+          SymbolDeclaration(path: "\(scope.path).\(name)", kind: .member, node: Syntax(node), parent: scope.node)
+        )
+      }
+    }
+    return .skipChildren
+  }
+
+  /// `name` inside the innermost type, without backticks: `` `default` `` is `default`.
+  private func qualified(_ name: String) -> String {
+    let name = withoutBackticks(name)
+    return scopes.last.map { "\($0.path).\(name)" } ?? name
+  }
+}
+
+/// Removes from the member blocks of `parents` every member that isn't in `kept`, except the type
+/// aliases. An `#if` block stays with the kept members inside it.
+private final class MemberPruner: SyntaxRewriter {
+  private let parents: Set<SyntaxIdentifier>
+  private let kept: Set<SyntaxIdentifier>
+
+  init(parents: Set<SyntaxIdentifier>, kept: Set<SyntaxIdentifier>) {
+    self.parents = parents
+    self.kept = kept
+    super.init(viewMode: .sourceAccurate)
+  }
+
+  override func visit(_ node: MemberBlockSyntax) -> MemberBlockSyntax {
+    guard let parent = node.parent, parents.contains(parent.id) else {
+      return super.visit(node)
+    }
+    return node.with(\.members, prune(node.members))
+  }
+
+  private func prune(_ members: MemberBlockItemListSyntax) -> MemberBlockItemListSyntax {
+    MemberBlockItemListSyntax(
+      members.compactMap { item -> MemberBlockItemSyntax? in
+        // The macros resolve the type aliases of the type in the types of its members.
+        if kept.contains(item.decl.id) || item.decl.is(TypeAliasDeclSyntax.self) {
+          return item
+        }
+        guard let ifConfig = item.decl.as(IfConfigDeclSyntax.self) else {
+          return nil
+        }
+        let clauses = ifConfig.clauses.map { clause -> IfConfigClauseSyntax in
+          guard case .decls(let decls) = clause.elements else {
+            return clause
+          }
+          return clause.with(\.elements, .decls(prune(decls)))
+        }
+        let keepsMember = clauses.contains { clause in
+          guard case .decls(let decls) = clause.elements else {
+            return false
+          }
+          // A clause with only type aliases left keeps no member.
+          return decls.contains { !$0.decl.is(TypeAliasDeclSyntax.self) }
+        }
+        return keepsMember
+          ? item.with(\.decl, DeclSyntax(ifConfig.with(\.clauses, IfConfigClauseListSyntax(clauses)))) : nil
+      }
+    )
+  }
+}

package/apple/Sources/ExpoModulesMacros/{EventMacro.swift → Macros/EventMacro.swift}

@@ -58,7 +58,7 @@ public struct EventMacro: AccessorMacro {
     let emitMethod = event.isSync ? "emitSync" : "emit"
     let closure: String
     if let tuple = event.payloadType.flatMap({ tupleConversion(of: $0) }) {
-      let encode = elementClosure(returning: tuple.encodeExpression(of: "value"))
+      let encode = encoderClosure(encoding: tuple.encodeCall(of: "value", into: "slot"))
       closure =
         "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload, encode: \(encode)) }"
     } else if event.hasPayload {

package/apple/Sources/ExpoModulesMacros/{RecordMacro.swift → Macros/RecordMacro.swift}

@@ -551,9 +551,11 @@ private func objectWriteLines(properties: [RecordProperty], of record: String, c
       encode = "try JavaScriptValue.encodeAny(\(value) as Any, in: runtime)"
     case nil:
       let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
-      // A type that holds a tuple has no `encode(_:into:in:)`, so its encoded value is written instead.
+      // A type that holds a tuple has no `encode(_:into:in:)`, so the tuple methods encode it into the
+      // property's slot.
       if let tuple = tupleConversion(of: property.type) {
-        return "  object.setProperty(\(propName), value: try \(tuple.encodeExpression(of: value)))"
+        return
+          "  try object.setProperty(\(propName)) { slot, runtime in try \(tuple.encodeCall(of: value, into: "slot")) }"
       }
       return "  try object.setProperty(\(propName), encoding: \(value))"
     }

package/apple/Sources/ExpoModulesMacros/{UnionMacro.swift → Macros/UnionMacro.swift}

@@ -332,8 +332,8 @@ private func encodeIntoSlotMethod(union: UnionType) -> DeclSyntax {
   for unionCase in union.cases {
     lines.append("  case \(unionCase.pattern):")
     if let tuple = tupleConversion(of: unionCase.payloadType) {
-      // A payload that holds a tuple has no `encode(_:into:in:)`, so its encoded value is moved in.
-      lines.append("    slot.emplace(try \(tuple.encodeExpression(of: "payload")))")
+      // A payload that holds a tuple has no `encode(_:into:in:)`, so the tuple methods encode it into the slot.
+      lines.append("    try \(tuple.encodeCall(of: "payload", into: "slot"))")
     } else {
       lines.append("    try \(expressionType(unionCase.payloadType)).encode(payload, into: slot, in: runtime)")
     }

package/apple/Sources/ExpoModulesMacros/Plugin.swift

@@ -1,4 +1,4 @@
-import ExpoModulesScanner
+import ExpoModulesCLI
 import SwiftCompilerPlugin
 import SwiftSyntaxMacros
 
@@ -11,23 +11,14 @@ import CRT
 #endif
 
 struct ExpoModulesMacrosPlugin: CompilerPlugin {
-  let providingMacros: [Macro.Type] = [
-    OptimizedFunctionAttachedMacro.self,
-    JSMacro.self,
-    EventMacro.self,
-    ExpoModuleMacro.self,
-    SharedObjectMacro.self,
-    RecordMacro.self,
-    UnionMacro.self,
-    ViewPropsMacro.self,
-    ExpoViewMacro.self,
-  ]
+  let providingMacros: [Macro.Type] = ProvidedMacro.all.map(\.type)
 }
 
 /// The executable doubles as the scanner CLI. The compiler always launches a plugin executable
 /// without arguments and speaks the plugin protocol over stdin, so any argument means a scanner
 /// invocation (`ExpoModulesMacros scan-modules <path>...`); with none, this starts the plugin
-/// server exactly as `@main` on the `CompilerPlugin` type would.
+/// server exactly as `@main` on the `CompilerPlugin` type would. The CLI gets `expandMacros`, so
+/// `expand` runs the macros of this executable.
 @main
 enum EntryPoint {
   static func main() throws {
@@ -35,7 +26,11 @@ enum EntryPoint {
     if arguments.isEmpty {
       try ExpoModulesMacrosPlugin.main()
     } else {
-      exit(ScannerCLI.run(arguments: arguments))
+      let expander = MacroExpander(
+        attributeNames: Set(ProvidedMacro.all.map(\.name)),
+        expand: expandMacros
+      )
+      exit(ScannerCLI.run(arguments: arguments, expander: expander))
     }
   }
 }

package/apple/Sources/ExpoModulesMacros/ProvidedMacros.swift

@@ -0,0 +1,31 @@
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+/// A macro that the plugin provides, with the attribute name and the extension conformances of its
+/// declaration in `expo-modules-core`.
+struct ProvidedMacro {
+  let name: String
+  let type: Macro.Type
+  var conformances: [TypeSyntax] = []
+
+  /// Every macro of the plugin. The compiler gets the types from `providingMacros`, and `expand`
+  /// matches the attributes by name and passes the same conformances as the compiler, so both read
+  /// this list.
+  static var all: [ProvidedMacro] {
+    [
+      ProvidedMacro(name: "OptimizedFunction", type: OptimizedFunctionAttachedMacro.self),
+      ProvidedMacro(name: "JS", type: JSMacro.self),
+      ProvidedMacro(name: "Event", type: EventMacro.self),
+      ProvidedMacro(name: "ExpoModule", type: ExpoModuleMacro.self, conformances: ["AnyModule"]),
+      ProvidedMacro(name: "SharedObject", type: SharedObjectMacro.self),
+      ProvidedMacro(name: "Record", type: RecordMacro.self, conformances: ["Record"]),
+      ProvidedMacro(
+        name: "Union",
+        type: UnionMacro.self,
+        conformances: ["JavaScriptDecodable", "JavaScriptEncodable"]
+      ),
+      ProvidedMacro(name: "ViewProps", type: ViewPropsMacro.self, conformances: ["AnyViewProps"]),
+      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self),
+    ]
+  }
+}

package/apple/Sources/ExpoModulesMacros/{ClosureArguments.swift → Support/ClosureArguments.swift}

@@ -177,9 +177,11 @@ private func closureLiteralLines(_ closure: JSClosureType, callback: String) ->
     var lines = [header, "  \(call) { _values, _arguments, _runtime in"]
     for (index, parameter) in closure.parameters.enumerated() {
       let value = parameters.count == 1 ? "_values" : "_values.\(index)"
-      // A parameter that holds a tuple has no `encode(_:into:in:)`, so its encoded value is moved in.
+      // A parameter that holds a tuple has no `encode(_:into:in:)`, so the tuple methods encode it into the
+      // argument's slot.
       if let tuple = tupleConversion(of: parameter.type) {
-        lines.append("    _arguments.emplace(try \(tuple.encodeExpression(of: value, in: "_runtime")), at: \(index))")
+        let encode = tuple.encodeCall(of: value, into: "slot", in: "_runtime")
+        lines.append("    try _arguments.emplace(at: \(index)) { slot in try \(encode) }")
       } else {
         lines.append("    try _arguments.emplace(\(value), at: \(index), in: _runtime)")
       }

package/apple/Sources/ExpoModulesMacros/{DecorateModuleBuilder.swift → Support/DecorateModuleBuilder.swift}

@@ -334,13 +334,18 @@ internal struct JSFunction {
     // The parameter list is parenthesized and fully typed, since Swift rejects a type annotation on
     // a shorthand `{ [capture] name, name in }` parameter.
     // A sync function binds through the result-slot overload (`JavaScriptRuntime.HostFunctionClosure`):
-    // it encodes its result into the slot and gets the runtime as a parameter. A function that returns
-    // nothing writes nothing, so JS gets `undefined` without a value being built.
+    // it encodes its result into the slot and gets the runtime as a parameter. A sync function that
+    // returns nothing binds through the `Void` overload (`JavaScriptRuntime.VoidFunctionClosure`)
+    // instead, which leaves JS's result as `undefined`. A call through it is faster than through a
+    // result-slot closure that writes nothing. The closure declares `-> Void` because a body of several
+    // statements without a `return` is otherwise ambiguous between the overloads.
     let captures = receiver.captureClause
     let parameters =
       isAsync
       ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-      : resultSlotClosureParameters
+      : returnType == nil
+        ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) -> Void"
+        : resultSlotClosureParameters
 
     return """
         \(object).setProperty("\(jsName)") { \(captures)\(parameters) in
@@ -499,14 +504,17 @@ private let resultSlotClosureParameters =
   + "result: borrowing JavaScriptValue.Slot, runtime: borrowing JavaScriptRuntime)"
 
 /// The statement that encodes `valueExpression` of a boundary type into the result slot `result`. A type
-/// that mentions `Any` and a tuple have no `encode(_:into:in:)`, so their encode result is moved into
-/// the slot.
+/// that mentions `Any` has no `encode(_:into:in:)`, so its free-form encode result is moved into the slot,
+/// and a type that holds a tuple is encoded into the slot by the tuple methods.
 private func encodeIntoSlotStatement(_ type: String, freeForm: FreeFormConversion?, of valueExpression: String)
   -> String
 {
-  if freeForm != nil || tupleConversion(of: type) != nil {
+  if freeForm != nil {
     return "result.emplace(try \(encodeCall(type, freeForm: freeForm, of: valueExpression)))"
   }
+  if let tuple = tupleConversion(of: type) {
+    return "try \(tuple.encodeCall(of: valueExpression, into: "result"))"
+  }
   return "try \(expressionType(type)).encode(\(valueExpression), into: result, in: runtime)"
 }