expo-modules-macros 0.25.0 → 0.27.0

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/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 → ExpoModulesCLI/Commands/ScanExports}/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/apple/Sources/{ExpoModulesScanner → ExpoModulesCLI}/Core/SourceScan.swift

@@ -102,7 +102,13 @@ struct MacroPrefilter {
   private let bareNames: [[UInt8]]
 
   init(macros: Set<DetectedMacro>, conformances: Set<String> = []) {
-    attributes = macros.map { Array($0.rawValue.utf8) }
+    self.init(attributeNames: Set(macros.map(\.rawValue)), conformances: conformances)
+  }
+
+  /// A pre-filter for attributes that `DetectedMacro` doesn't list, such as every macro that `expand`
+  /// runs.
+  init(attributeNames: Set<String>, conformances: Set<String> = []) {
+    attributes = attributeNames.map { Array($0.utf8) }
     bareNames = conformances.map { Array($0.utf8) }
   }
 
@@ -196,7 +202,7 @@ func swiftFiles(in paths: [String]) -> [String] {
 }
 
 /// Whether `path` is a directory (following symbolic links), or `nil` if nothing exists there.
-private func isDirectory(atPath path: String, fileManager: FileManager) -> Bool? {
+func isDirectory(atPath path: String, fileManager: FileManager = .default) -> Bool? {
   #if canImport(FoundationEssentials)
   var isDirectory = false
   #else