@expo/expo-module-optimized-macros-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Expo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/apple/ExpoModulesOptimizedMacros.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoModulesOptimizedMacro'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1',
+    :osx => '11.0',
+  }
+  s.source         = { git: 'https://github.com/expo/expo-module-optimized-macros-plugin.git' }
+  s.source_files   = 'Sources/ExpoModulesOptimized/**/*.swift'
+end

package/apple/Package.resolved

@@ -0,0 +1,15 @@
+{
+  "originHash" : "4832fa479257148c1acb46952c02540c156db6e744797638db69be31154d5ad2",
+  "pins" : [
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftlang/swift-syntax.git",
+      "state" : {
+        "revision" : "4799286537280063c85a32f09884cfbca301b1a1",
+        "version" : "602.0.0"
+      }
+    }
+  ],
+  "version" : 3
+}

package/apple/Package.swift

@@ -0,0 +1,38 @@
+// swift-tools-version: 6.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+  name: "ExpoModulesOptimized",
+  platforms: [.macOS(.v10_15)],
+  products: [
+    .executable(
+      name: "ExpoModulesOptimized",
+      targets: ["ExpoModulesOptimized"]
+    ),
+  ],
+  dependencies: [
+    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "602.0.0-latest"),
+  ],
+  targets: [
+    .macro(
+      name: "ExpoModulesOptimizedMacros",
+      dependencies: [
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+      ]
+    ),
+
+    .executableTarget(name: "ExpoModulesOptimized", dependencies: ["ExpoModulesOptimizedMacros"]),
+
+    .testTarget(
+      name: "ExpoModulesOptimizedTests",
+      dependencies: [
+        "ExpoModulesOptimizedMacros",
+        .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+      ]
+    ),
+  ]
+)

package/apple/Sources/ExpoModulesOptimized/ExpoModulesOptimized.swift

@@ -0,0 +1,30 @@
+/// An attached macro that generates an optimized synchronous function descriptor.
+/// Creates a peer function that returns `OptimizedFunctionDescriptor`, for use with
+/// the `Function("name", descriptor)` overload in ModuleDefinition result builders.
+///
+/// Usage:
+///
+///     @OptimizedFunction
+///     private func addNumbers(a: Double, b: Double) -> Double {
+///         return a + b
+///     }
+///
+///     // In definition():
+///     Function("addNumbers", addNumbers())
+///
+/// You can also provide an explicit peer name if the Swift function name differs:
+///
+///     @OptimizedFunction("addNumbers")
+///     private func addNumbersImpl(a: Double, b: Double) -> Double { ... }
+///
+///     // In definition():
+///     Function("addNumbers", addNumbers())
+///
+/// The generated peer function uses the optimized JSI bridge path with
+/// @convention(block) closures for maximum performance.
+@attached(peer, names: arbitrary)
+public macro OptimizedFunction(_ name: String) = #externalMacro(module: "ExpoModulesOptimizedMacros", type: "OptimizedFunctionAttachedMacro")
+
+/// Variant that derives the peer function name from the Swift function name.
+@attached(peer, names: arbitrary)
+public macro OptimizedFunction() = #externalMacro(module: "ExpoModulesOptimizedMacros", type: "OptimizedFunctionAttachedMacro")

package/apple/Sources/ExpoModulesOptimizedMacros/ExpoModulesOptimizedMacro.swift

@@ -0,0 +1,184 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import Foundation
+
+// MARK: - Helper Functions
+
+/// Generates Objective-C type encoding string for the given signature
+internal func generateTypeEncoding(returnType: String, paramTypes: [String]) throws -> String {
+  var encoding = ""
+
+  // Encode return type
+  guard let returnEncoding = typeToEncoding(returnType) else {
+    throw MacroExpansionErrorMessage("Unsupported return type: \(returnType)")
+  }
+  encoding += returnEncoding
+
+  // Add block marker
+  encoding += "@?"
+
+  // Encode parameters
+  for paramType in paramTypes {
+    guard let paramEncoding = typeToEncoding(paramType) else {
+      throw MacroExpansionErrorMessage("Unsupported parameter type: \(paramType)")
+    }
+    encoding += paramEncoding
+  }
+
+  return encoding
+}
+
+/// Maps Swift type to Objective-C type encoding character
+internal func typeToEncoding(_ type: String) -> String? {
+  switch type {
+  case "Double":
+    return "d"
+  case "Int", "Int64":
+    return "q"
+  case "String":
+    return "@"
+  case "Bool":
+    return "B"
+  case "Void", "()":
+    return "v"
+  default:
+    return nil
+  }
+}
+
+// MARK: - Macro Implementation
+
+/// Implementation of the `@OptimizedFunction` attached macro.
+/// Generates a peer function that returns `OptimizedFunctionDescriptor` for use with
+/// the `Function("name", descriptor)` or `AsyncFunction("name", descriptor)` overload.
+///
+/// Usage:
+///
+///     @OptimizedFunction
+///     private func addNumbers(a: Double, b: Double) -> Double {
+///         return a + b
+///     }
+///
+/// generates a peer function:
+///
+///     private func addNumbers() -> OptimizedFunctionDescriptor {
+///         return OptimizedSyncFunctionDefinition.createDescriptor(
+///             typeEncoding: "d@?dd",
+///             argsCount: 2,
+///             block: (addNumbers as @convention(block) (Double, Double) -> Double) as AnyObject
+///         )
+///     }
+///
+/// Then use in definition(): `Function("addNumbers", addNumbers())`
+public struct OptimizedFunctionAttachedMacro: PeerMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingPeersOf declaration: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
+      throw MacroExpansionErrorMessage("@OptimizedFunction can only be attached to function declarations")
+    }
+
+    // Extract the function name from the macro argument, or default to the Swift function name
+    let functionName: String
+    if case let .argumentList(arguments) = node.arguments,
+       let firstArg = arguments.first,
+       let nameExpr = firstArg.expression.as(StringLiteralExprSyntax.self),
+       let nameSegment = nameExpr.segments.first?.as(StringSegmentSyntax.self) {
+      functionName = nameSegment.content.text
+    } else {
+      functionName = funcDecl.name.text
+    }
+
+    var paramTypes: [String] = []
+    for param in funcDecl.signature.parameterClause.parameters {
+      paramTypes.append(param.type.trimmedDescription)
+    }
+
+    let returnType = funcDecl.signature.returnClause?.type.trimmedDescription ?? "Void"
+    let functionThrows = funcDecl.signature.effectSpecifiers?.throwsClause?.throwsSpecifier != nil
+    let typeEncoding = try generateTypeEncoding(returnType: returnType, paramTypes: paramTypes)
+    let implFuncName = funcDecl.name.text
+    let blockParamTypes = paramTypes.joined(separator: ", ")
+    let argNames = (0..<paramTypes.count).map { "arg\($0)" }.joined(separator: ", ")
+
+    let peerFunc: DeclSyntax
+
+    if functionThrows {
+      let isVoid = returnType == "Void" || returnType == "()"
+      let implType = paramTypes.isEmpty ? "() throws -> \(returnType)" : "(\(blockParamTypes)) throws -> \(returnType)"
+      let wrapperType = paramTypes.isEmpty ? "@convention(block) () -> \(returnType)" : "@convention(block) (\(blockParamTypes)) -> \(returnType)"
+      let closureArgs = paramTypes.isEmpty ? "" : " \(argNames) in"
+      let implCall = paramTypes.isEmpty ? "impl()" : "impl(\(argNames))"
+      let tryExpr = isVoid ? "try \(implCall)" : "return try \(implCall)"
+      let unreachable = isVoid ? "" : "\n      fatalError(\"Unreachable\")"
+
+      peerFunc = """
+        private func \(raw: functionName)() -> OptimizedFunctionDescriptor {
+          let impl: \(raw: implType) = \(raw: implFuncName)
+          let wrapper: \(raw: wrapperType) = {\(raw: closureArgs)
+            do {
+              \(raw: tryExpr)
+            } catch {
+              let nsError: NSError
+              if let expoError = error as? Exception {
+                nsError = NSError(domain: "dev.expo.modules", code: 0, userInfo: [
+                  "name": expoError.name,
+                  "code": expoError.code,
+                  "message": expoError.debugDescription,
+                ])
+              } else {
+                nsError = error as NSError
+              }
+              let exception = NSException(
+                name: NSExceptionName(nsError.userInfo["name"] as? String ?? "SwiftError"),
+                reason: nsError.userInfo["message"] as? String ?? nsError.localizedDescription,
+                userInfo: nsError.userInfo
+              )
+              exception.raise()\(raw: unreachable)
+            }
+          }
+          return OptimizedSyncFunctionDefinition.createDescriptor(
+            typeEncoding: "\(raw: typeEncoding)",
+            argsCount: \(raw: String(paramTypes.count)),
+            block: wrapper as AnyObject
+          )
+        }
+        """
+    } else {
+      peerFunc = """
+        private func \(raw: functionName)() -> OptimizedFunctionDescriptor {
+          return OptimizedSyncFunctionDefinition.createDescriptor(
+            typeEncoding: "\(raw: typeEncoding)",
+            argsCount: \(raw: String(paramTypes.count)),
+            block: (\(raw: implFuncName) as @convention(block) (\(raw: blockParamTypes)) -> \(raw: returnType)) as AnyObject
+          )
+        }
+        """
+    }
+
+    return [peerFunc]
+  }
+}
+
+struct MacroExpansionErrorMessage: Error, CustomStringConvertible {
+  let message: String
+
+  init(_ message: String) {
+    self.message = message
+  }
+
+  var description: String {
+    return message
+  }
+}
+
+@main
+struct ExpoModulesOptimizedPlugin: CompilerPlugin {
+  let providingMacros: [Macro.Type] = [
+    OptimizedFunctionAttachedMacro.self,
+  ]
+}

package/apple/build.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const { execSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const distRoot = path.resolve(__dirname, 'dist');
+
+try {
+  fs.mkdirSync(distRoot, { recursive: true });
+  execSync('swift build -c release', { stdio: 'inherit', cwd: __dirname });
+
+  fs.copyFileSync(
+    path.join(__dirname, '.build/arm64-apple-macosx/release/ExpoModulesOptimizedMacros-tool'),
+    path.join(distRoot, 'ExpoModulesOptimizedMacros-tool')
+  );
+
+  fs.copyFileSync(
+    path.join(__dirname, 'Sources/ExpoModulesOptimized/ExpoModulesOptimized.swift'),
+    path.join(distRoot, 'ExpoModulesOptimized.swift')
+  );
+} catch (error) {
+  console.error('Build failed:', error.message);
+  process.exit(1);
+}

package/apple/dist/ExpoModulesOptimized.swift

@@ -0,0 +1,30 @@
+/// An attached macro that generates an optimized synchronous function descriptor.
+/// Creates a peer function that returns `OptimizedFunctionDescriptor`, for use with
+/// the `Function("name", descriptor)` overload in ModuleDefinition result builders.
+///
+/// Usage:
+///
+///     @OptimizedFunction
+///     private func addNumbers(a: Double, b: Double) -> Double {
+///         return a + b
+///     }
+///
+///     // In definition():
+///     Function("addNumbers", addNumbers())
+///
+/// You can also provide an explicit peer name if the Swift function name differs:
+///
+///     @OptimizedFunction("addNumbers")
+///     private func addNumbersImpl(a: Double, b: Double) -> Double { ... }
+///
+///     // In definition():
+///     Function("addNumbers", addNumbers())
+///
+/// The generated peer function uses the optimized JSI bridge path with
+/// @convention(block) closures for maximum performance.
+@attached(peer, names: arbitrary)
+public macro OptimizedFunction(_ name: String) = #externalMacro(module: "ExpoModulesOptimizedMacros", type: "OptimizedFunctionAttachedMacro")
+
+/// Variant that derives the peer function name from the Swift function name.
+@attached(peer, names: arbitrary)
+public macro OptimizedFunction() = #externalMacro(module: "ExpoModulesOptimizedMacros", type: "OptimizedFunctionAttachedMacro")

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@expo/expo-module-optimized-macros-plugin",
+  "version": "0.0.1",
+  "description": "Swift macro plugin for optimized Expo module function definitions",
+  "license": "MIT",
+  "author": "650 Industries, Inc.",
+  "homepage": "https://github.com/expo/expo-module-optimized-macros-plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expo/expo-module-optimized-macros-plugin.git"
+  },
+  "scripts": {
+    "build": "node apple/build.js"
+  }
+}