expo-modules-macros 0.24.0 → 0.26.0

package/apple/Sources/ExpoModulesMacros/UnionMacro.swift

@@ -64,6 +64,7 @@ public struct UnionMacro: MemberMacro, ExtensionMacro {
     members.append(decodableKindsProperty(union: union))
     members.append(decodeMethod(union: union))
     members.append(encodeMethod(union: union))
+    members.append(encodeIntoSlotMethod(union: union))
     members.append(contentsOf: accessorMethods(union: union))
     members.append(payloadTypeNameProperty(union: union))
     return members
@@ -269,9 +270,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
 private func decodeMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  let kind = JavaScriptValueKinds(of: value)"]
   for unionCase in union.cases {
-    let payloadType = expressionType(unionCase.payloadType)
+    let conversion = payloadConversion(unionCase)
     lines.append(
-      "  if \(payloadType).decodableKinds.contains(kind), let payload = try? \(payloadType).decode(value, in: runtime) {"
+      "  if \(conversion.decodableKindsExpression).contains(kind), let payload = try? \(conversion.decodeExpression(of: "value")) {"
     )
     lines.append("    return \(unionCase.construction)")
     lines.append("  }")
@@ -292,7 +293,7 @@ private func decodeMethod(union: UnionType) -> DeclSyntax {
 /// `decodableKinds`: the union of the payloads' kinds, so a union nested in another union, or wrapped
 /// in an optional, is skipped as precisely as its payloads are.
 private func decodableKindsProperty(union: UnionType) -> DeclSyntax {
-  let kinds = union.cases.map { "\(expressionType($0.payloadType)).decodableKinds" }
+  let kinds = union.cases.map { payloadConversion($0).decodableKindsExpression }
   // An option set's array literal is the union of its elements, which reads like the case list. The
   // optimizer folds it to a constant after specialization, the same as a chain of `union(_:)` calls.
   let expression = kinds.count == 1 ? kinds[0] : "[\(kinds.joined(separator: ", "))]"
@@ -310,7 +311,7 @@ private func encodeMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  switch value {"]
   for unionCase in union.cases {
     lines.append("  case \(unionCase.pattern):")
-    lines.append("    return try \(expressionType(unionCase.payloadType)).encode(payload, in: runtime)")
+    lines.append("    return try \(payloadConversion(unionCase).encodeExpression(of: "payload"))")
   }
   lines.append("  }")
   let body = lines.joined(separator: "\n")
@@ -322,6 +323,35 @@ private func encodeMethod(union: UnionType) -> DeclSyntax {
     """
 }
 
+/// `encode(_:into:in:)`: the same `switch` as `encode(_:in:)`, with each payload encoded straight into the
+/// slot through the payload type's own `encode(_:into:in:)`. A payload that is a number, a boolean or a
+/// string is then constructed in the slot (an array element, an argument or a result), with no
+/// `JavaScriptValue` in between.
+private func encodeIntoSlotMethod(union: UnionType) -> DeclSyntax {
+  var lines: [String] = ["  switch value {"]
+  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")))")
+    } else {
+      lines.append("    try \(expressionType(unionCase.payloadType)).encode(payload, into: slot, in: runtime)")
+    }
+  }
+  lines.append("  }")
+  let body = lines.joined(separator: "\n")
+  return """
+    @JavaScriptActor
+    public static func encode(
+      _ value: Self,
+      into slot: borrowing JavaScriptValue.Slot,
+      in runtime: borrowing JavaScriptRuntime
+    ) throws {
+    \(raw: body)
+    }
+    """
+}
+
 /// `as(_:)`: a typed accessor per case, selected by the payload's metatype rather than the case name,
 /// so a caller that only knows the type it wants writes `try value.as(String.self)` and gets a `String`.
 /// When
@@ -414,3 +444,9 @@ private struct UnionFixItMessage: FixItMessage {
     self.fixItID = MessageID(domain: "ExpoModulesMacros", id: id)
   }
 }
+
+/// How a case's payload converts: through the tuple methods when it holds a tuple (see
+/// `TupleConversion`), and through its own `decode` / `encode` otherwise.
+private func payloadConversion(_ unionCase: UnionCase) -> TupleConversion {
+  return tupleConversion(of: unionCase.payloadType) ?? .conforming(type: unionCase.payloadType)
+}

package/apple/Sources/ExpoModulesScanner/Exports/ExportedSurface.swift

@@ -463,8 +463,9 @@ struct ExportedSurface: Encodable, Equatable {
 /// qualified names and gives a resolved ref the name of its declaration; version 8 reports
 /// declarations in `#if` blocks, adds `platforms` (with deprecations), `accessLevel`, and
 /// `defaultValue`, and replaces `constructorParameters` with `initializer`; version 9 adds the
-/// `sharedRef` type kind and the `sharedRef` of a shared object.
-let scanExportsSchemaVersion = 9
+/// `sharedRef` type kind and the `sharedRef` of a shared object; version 10 adds the `tuple` and `object` type kinds (named after a tuple alias)
+/// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes.
+let scanExportsSchemaVersion = 10
 
 /// The `scan-exports` result: the surface plus the run's stats. A distinct envelope from
 /// `ScanModulesResult` (different consumer: TS generation vs. autolinking).

package/apple/Sources/ExpoModulesScanner/Exports/ResolveRefs.swift

@@ -136,6 +136,15 @@ extension TypeNode {
       )
     case .promise(let value):
       return .promise(value: value.resolvingRefs(using: index, in: scope))
+    case .tuple(let elements, let name):
+      return .tuple(elements: elements.map { $0.resolvingRefs(using: index, in: scope) }, name: name)
+    case .object(let properties, let name):
+      return .object(
+        properties: properties.map {
+          TypeNodeProperty(name: $0.name, type: $0.type.resolvingRefs(using: index, in: scope))
+        },
+        name: name
+      )
     case .function(let parameters, let returns, let isAsync, let isThrowing):
       return .function(
         parameters: parameters.map { $0.resolvingRefs(using: index, in: scope) },

package/apple/Sources/ExpoModulesScanner/Exports/SurfaceVisitor.swift

@@ -142,13 +142,14 @@ final class SurfaceVisitor: SyntaxVisitor {
       guard scope.isEmpty else {
         return
       }
+      let aliases = TupleTypeAliases(in: members, scope: qualified)
       let (functions, properties, events, _) = collectJSMembers(members)
       modules.append(
         ExportedModule(
           name: qualified,
           jsName: stringArgument(of: attribute) ?? name,
-          functions: functions,
-          properties: properties,
+          functions: functions.map(aliases.resolving),
+          properties: properties.map(aliases.resolving),
           events: events,
           // `jsName` is filled in by `ExportedSurface.resolvingRefs()`, since the `@SharedObject` can
           // be declared in another file.
@@ -164,7 +165,13 @@ final class SurfaceVisitor: SyntaxVisitor {
     }
 
     if let attribute = attributes.firstAttribute(named: DetectedMacro.sharedObject.rawValue) {
-      let (functions, properties, events, initializer) = collectJSMembers(members)
+      let aliases = TupleTypeAliases(in: members, scope: qualified)
+      var (functions, properties, events, initializer) = collectJSMembers(members)
+      functions = functions.map(aliases.resolving)
+      properties = properties.map(aliases.resolving)
+      if let parameters = initializer?.parameters {
+        initializer?.parameters = parameters.map(aliases.resolving)
+      }
       sharedObjects.append(
         ExportedSharedObject(
           name: qualified,

package/apple/Sources/ExpoModulesScanner/Exports/TupleTypeAliases.swift

@@ -0,0 +1,126 @@
+import SwiftSyntax
+
+/// The type aliases declared in the body of an `@ExpoModule` or `@SharedObject` class whose aliased type
+/// holds a tuple, resolved to that type. Mirrors `TupleTypeAliases` in the macros, which resolve these
+/// aliases in the `@JS` members the class binds, so that a member typed with such an alias reports the
+/// tuple it converts as instead of an unresolvable ref.
+///
+/// Like the macros, it reads only the class body: an alias declared anywhere else stays a ref. A generic
+/// alias isn't resolved, and neither is an alias in an `@Event` payload, which `@Event` converts on its
+/// own.
+struct TupleTypeAliases {
+  /// The resolved type of each alias, by name.
+  private let resolved: [String: TypeNode]
+
+  /// Collects the aliases in `members`, the body of the type named `scope`. A tuple alias keeps its name
+  /// qualified with `scope`, like the other declarations in the scan, so a consumer can name the type it
+  /// stands for.
+  init(in members: MemberBlockItemListSyntax, scope: String) {
+    var declared: [String: TypeNode] = [:]
+    for member in members {
+      guard let alias = member.decl.as(TypeAliasDeclSyntax.self), alias.genericParameterClause == nil else {
+        continue
+      }
+      let name = alias.name.text
+      declared[name] = typeNode(from: alias.initializer.value).named("\(scope).\(name)")
+    }
+    // Aliases may refer to each other, so each one is resolved through the others. An alias that refers
+    // back to itself is invalid Swift, and is left as written after `declared.count` rounds.
+    var resolved = declared
+    for _ in 0..<declared.count {
+      resolved = resolved.mapValues { $0.replacingAliases(resolved) }
+    }
+    self.resolved = resolved.filter { $0.value.holdsTuple }
+  }
+
+  /// `node` with each ref to an alias that holds a tuple replaced by the aliased type.
+  func resolving(_ node: TypeNode) -> TypeNode {
+    guard !resolved.isEmpty else {
+      return node
+    }
+    return node.replacingAliases(resolved)
+  }
+
+  func resolving(_ function: ExportedFunction) -> ExportedFunction {
+    var resolvedFunction = function
+    resolvedFunction.parameters = function.parameters.map(resolving)
+    resolvedFunction.returns = function.returns.map(resolving)
+    return resolvedFunction
+  }
+
+  func resolving(_ property: ExportedProperty) -> ExportedProperty {
+    var resolvedProperty = property
+    resolvedProperty.type = property.type.map(resolving)
+    return resolvedProperty
+  }
+
+  func resolving(_ parameter: ExportedParameter) -> ExportedParameter {
+    var resolvedParameter = parameter
+    resolvedParameter.type = resolving(parameter.type)
+    return resolvedParameter
+  }
+}
+
+extension TypeNode {
+  /// This node with each ref named in `aliases`, bare (`Span`) or qualified with `Self` (`Self.Span`),
+  /// replaced by the aliased type.
+  fileprivate func replacingAliases(_ aliases: [String: TypeNode]) -> TypeNode {
+    switch self {
+    case .primitive, .unknown, .sharedRef:
+      return self
+    case .ref(let name, _, _):
+      let unqualified = name.hasPrefix("Self.") ? String(name.dropFirst("Self.".count)) : name
+      return aliases[unqualified] ?? self
+    case .optional(let wrapped):
+      return .optional(wrapped: wrapped.replacingAliases(aliases))
+    case .array(let element):
+      return .array(element: element.replacingAliases(aliases))
+    case .dictionary(let key, let value):
+      return .dictionary(key: key.replacingAliases(aliases), value: value.replacingAliases(aliases))
+    case .promise(let value):
+      return .promise(value: value.replacingAliases(aliases))
+    case .tuple(let elements, let name):
+      return .tuple(elements: elements.map { $0.replacingAliases(aliases) }, name: name)
+    case .object(let properties, let name):
+      return .object(
+        properties: properties.map { TypeNodeProperty(name: $0.name, type: $0.type.replacingAliases(aliases)) },
+        name: name
+      )
+    case .function(let parameters, let returns, let isAsync, let isThrowing):
+      return .function(
+        parameters: parameters.map { $0.replacingAliases(aliases) },
+        returns: returns?.replacingAliases(aliases),
+        isAsync: isAsync,
+        isThrowing: isThrowing
+      )
+    }
+  }
+
+  /// This node named `name` when it's a tuple or an object, which an alias names. Any other node, such as
+  /// an array of tuples, is returned as it is: its elements carry the names of their own aliases.
+  fileprivate func named(_ name: String) -> TypeNode {
+    switch self {
+    case .tuple(let elements, _):
+      return .tuple(elements: elements, name: name)
+    case .object(let properties, _):
+      return .object(properties: properties, name: name)
+    default:
+      return self
+    }
+  }
+
+  /// True for a type the macros convert through the tuple methods: a tuple (`.tuple`, or `.object` for a
+  /// labeled one), or an optional, array or `String`-keyed dictionary that holds one.
+  fileprivate var holdsTuple: Bool {
+    switch self {
+    case .tuple, .object:
+      return true
+    case .optional(let inner), .array(let inner):
+      return inner.holdsTuple
+    case .dictionary(.primitive("String", _), let value):
+      return value.holdsTuple
+    default:
+      return false
+    }
+  }
+}

package/apple/Sources/ExpoModulesScanner/Exports/TypeNode.swift

@@ -72,12 +72,22 @@ indirect enum TypeNode: Equatable {
   /// node parsed at a use site has never seen.
   case ref(name: String, refKind: RefKind? = nil, jsTypeOverride: JSType? = nil)
 
+  /// An unlabeled tuple of two or more elements, `(A, B)`, which crosses as an array with one value per
+  /// element, like a TypeScript tuple. `name` is the qualified name of the type alias it was written
+  /// through, such as `MyModule.Pair`, or `nil` when it was spelled out.
+  case tuple(elements: [TypeNode], name: String? = nil)
+
+  /// An object with a fixed set of properties, which a labeled tuple of two or more elements,
+  /// `(x: A, y: B)`, crosses as: one property per label. `name` is the qualified name of the type alias it
+  /// was written through, such as `MyModule.Span`, or `nil` when it was spelled out.
+  case object(properties: [TypeNodeProperty], name: String? = nil)
+
   /// `SharedRef<T>` (or `ExpoModulesCore.SharedRef<T>`): a shared object holding a native `T`, which
   /// JS sees as an instance of `expo.SharedRef`. `native` is `T` parsed like any other type, but it
   /// never crosses the boundary itself, so refs in it are not resolved.
   case sharedRef(native: TypeNode)
 
-  /// A spelling the parser doesn't model (generic parameter, tuple, metatype, …), kept verbatim so
+  /// A spelling the parser doesn't model (generic parameter, metatype, …), kept verbatim so
   /// nothing is lost. Has no `typeof`.
   case unknown(text: String)
 
@@ -87,7 +97,7 @@ indirect enum TypeNode: Equatable {
     switch self {
     case .primitive(_, let jsType):
       return jsType
-    case .array, .dictionary, .promise, .sharedRef:
+    case .array, .dictionary, .promise, .tuple, .object, .sharedRef:
       return .object
     case .ref(_, _, let jsTypeOverride):
       // An unresolved ref, and every resolved one but an enum, is an object.
@@ -102,6 +112,12 @@ indirect enum TypeNode: Equatable {
   }
 }
 
+/// A property of a `.object` node: its name, and the type of its value.
+struct TypeNodeProperty: Encodable, Equatable {
+  let name: String
+  let type: TypeNode
+}
+
 extension TypeNode: Encodable {
   private enum CodingKeys: String, CodingKey {
     case refKind
@@ -110,7 +126,7 @@ extension TypeNode: Encodable {
     // The `typeof` category. Spelled `typeof` in JSON (what the consumer reads); the Swift property is
     // `jsType` since it's the cleaner Swift name.
     case jsType = "typeof"
-    case wrapped, element, key, value, parameters, returns, text, native
+    case wrapped, element, key, value, parameters, returns, text, native, elements, properties
     // A closure type's effects, matching `ExportedFunction`'s TS-keyword spellings.
     case isAsync = "async"
     case isThrowing = "throws"
@@ -148,6 +164,14 @@ extension TypeNode: Encodable {
       try container.encode("ref", forKey: .kind)
       try container.encode(name, forKey: .name)
       try container.encodeIfPresent(refKind, forKey: .refKind)
+    case .tuple(let elements, let name):
+      try container.encode("tuple", forKey: .kind)
+      try container.encode(elements, forKey: .elements)
+      try container.encodeIfPresent(name, forKey: .name)
+    case .object(let properties, let name):
+      try container.encode("object", forKey: .kind)
+      try container.encode(properties, forKey: .properties)
+      try container.encodeIfPresent(name, forKey: .name)
     case .sharedRef(let native):
       try container.encode("sharedRef", forKey: .kind)
       try container.encode(native, forKey: .native)
@@ -228,7 +252,22 @@ func typeNode(from type: TypeSyntax) -> TypeNode {
     }
     return .ref(name: member.trimmedDescription)
   }
-  // Tuples, metatypes, some/any types, etc.: not modeled, preserve the verbatim spelling.
+  // `(A, B)` / `(x: A, y: B)`, matching the tuples the macros convert: two or more elements, all
+  // labeled or none, without a variadic or `inout` element.
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count >= 2,
+    tuple.elements.allSatisfy({ $0.ellipsis == nil && $0.inoutKeyword == nil })
+  {
+    let labels = tuple.elements.compactMap { $0.firstName?.text }
+    if labels.isEmpty {
+      return .tuple(elements: tuple.elements.map { typeNode(from: $0.type) })
+    }
+    if labels.count == tuple.elements.count {
+      return .object(
+        properties: zip(labels, tuple.elements).map { TypeNodeProperty(name: $0, type: typeNode(from: $1.type)) }
+      )
+    }
+  }
+  // Other tuples, metatypes, some/any types, etc.: not modeled, preserve the verbatim spelling.
   return .unknown(text: type.trimmedDescription)
 }
 
@@ -316,6 +355,10 @@ extension TypeNode {
       return "Promise<\(value.spelling)>"
     case .sharedRef(let native):
       return "SharedRef<\(native.spelling)>"
+    case .tuple(let elements, _):
+      return "(\(elements.map(\.spelling).joined(separator: ", ")))"
+    case .object(let properties, _):
+      return "(\(properties.map { "\($0.name): \($0.type.spelling)" }.joined(separator: ", ")))"
     case .function(let parameters, let returns, _, _):
       return "(\(parameters.map { $0.spelling }.joined(separator: ", "))) -> \(returns?.spelling ?? "Void")"
     case .unknown(let text):

package/build/types.d.ts

@@ -61,6 +61,37 @@ export type TypeNode = {
     name: string;
     refKind?: 'record' | 'sharedObject' | 'enum' | 'union';
 }
+/**
+ * An unlabeled Swift tuple of two or more elements, `(A, B)`. It crosses as an array with one value per
+ * element, like a TypeScript tuple.
+ */
+ | {
+    kind: 'tuple';
+    typeof: JSType;
+    elements: TypeNode[];
+    /**
+     * The qualified name of the type alias the tuple was written through, such as `MyModule.Pair`.
+     * Absent when the tuple is spelled out.
+     */
+    name?: string;
+}
+/**
+ * An object with a fixed set of properties. A labeled Swift tuple of two or more elements,
+ * `(x: A, y: B)`, crosses as one, with one property per label.
+ */
+ | {
+    kind: 'object';
+    typeof: JSType;
+    properties: {
+        name: string;
+        type: TypeNode;
+    }[];
+    /**
+     * The qualified name of the type alias the labeled tuple was written through, such as
+     * `MyModule.Span`. Absent when the tuple is spelled out.
+     */
+    name?: string;
+}
 /**
  * `SharedRef<T>`: a shared object that JS sees as an instance of `expo.SharedRef`. `native` is the
  * `T` it holds on the native side. It never reaches JS, so refs in it are not resolved.
@@ -389,4 +420,4 @@ export interface ScanExportsResult {
  * as a clear error instead of silently misread fields.
  */
 export declare const SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 9;
+export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 10;

package/build/types.js

@@ -12,4 +12,4 @@ exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = exports.SUPPORTED_SCAN_MODULES_S
  * as a clear error instead of silently misread fields.
  */
 exports.SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 9;
+exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 10;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -26,9 +26,9 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-linux-arm64": "0.24.0",
-    "@expo/modules-macros-linux-x64": "0.24.0",
-    "@expo/modules-macros-win32-arm64": "0.24.0",
-    "@expo/modules-macros-win32-x64": "0.24.0"
+    "@expo/modules-macros-linux-arm64": "0.26.0",
+    "@expo/modules-macros-linux-x64": "0.26.0",
+    "@expo/modules-macros-win32-arm64": "0.26.0",
+    "@expo/modules-macros-win32-x64": "0.26.0"
   }
 }