expo-modules-macros 0.17.0-0 → 0.18.0

package/apple/Sources/ExpoModulesMacros/ClosureArguments.swift

@@ -68,29 +68,20 @@ internal struct JSClosureType {
     let isVariadic: Bool
 
     init(_ element: TupleTypeElementSyntax) {
-      if let attributed = element.type.as(AttributedTypeSyntax.self), !attributed.specifiers.isEmpty {
-        self.specifiers = attributed.specifiers.map(\.trimmedDescription)
-        self.type =
-          attributed.attributes.isEmpty
-          ? attributed.baseType : TypeSyntax(attributed.with(\.specifiers, []))
-      } else {
-        self.specifiers = []
-        self.type = element.type
-      }
+      let specified = SpecifiedType(element.type)
+      self.specifiers = specified.specifiers
+      self.type = specified.type
       self.isVariadic = element.ellipsis != nil
     }
 
-    /// The first specifier the wrapper can't support, such as `inout` or `isolated`.
+    /// The first specifier the wrapper can't support, such as `inout` or `isolated`. The wrapper passes
+    /// each parameter on to the callback, so an ownership convention doesn't change what it does.
     var unsupportedSpecifier: String? {
-      return specifiers.first { !supportedParameterSpecifiers.contains($0) }
+      return specifiers.first { !ownershipSpecifiers.contains($0) }
     }
   }
 }
 
-/// The ownership specifiers a closure parameter may carry. The wrapper passes each parameter on to the
-/// callback, so the ownership convention doesn't change what it does.
-private let supportedParameterSpecifiers: Set<String> = ["borrowing", "consuming", "sending", "__shared", "__owned"]
-
 /// The statements that bind `name` to the native value of a `@JS` argument read from
 /// `valueExpression` (a `JavaScriptUnownedValue`). A closure gets a wrapper around the JS function,
 /// and every other type decodes through `decodeCall`.
@@ -99,6 +90,8 @@ internal func argumentDecodeStatements(
   into name: String,
   from valueExpression: String
 ) -> [String] {
+  // A specifier such as `borrowing` belongs to the parameter, not to the type that decodes.
+  let type = SpecifiedType(type).type
   guard let closure = JSClosureType(type) else {
     return ["let \(name) = try \(decodeCall(type.trimmedDescription, from: valueExpression))"]
   }

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -24,7 +24,7 @@ internal struct JSFunction {
 
   init(funcDecl: FunctionDeclSyntax, attribute: AttributeSyntax) {
     self.swiftName = funcDecl.name.text
-    self.jsName = jsNameArgument(of: attribute) ?? funcDecl.name.text
+    self.jsName = jsNameArgument(of: attribute) ?? withoutBackticks(funcDecl.name.text)
     self.parameters = Array(funcDecl.signature.parameterClause.parameters)
 
     let declaredReturnType = funcDecl.signature.returnClause?.type
@@ -154,7 +154,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines().map { "  " + $0 })
     } else {
       lines.append("  \(callExpression(receiver: receiver, arity: arity))")
-      lines.append("  return .undefined")
+      lines.append("  return .undefined()")
     }
     lines.append("}")
     return lines
@@ -204,7 +204,7 @@ internal struct JSFunction {
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
   /// `let result = <callee>.f(...)` then the return encode (or the no-return `<callee>.f(...)` +
-  /// `.undefined`).
+  /// `.undefined()`).
   private func callAndEncodeLines(receiver: Receiver, arity: Int, decodingFrom: Int) -> [String] {
     var lines: [String] = []
     for index in decodingFrom..<arity {
@@ -215,7 +215,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines())
     } else {
       lines.append(callExpression(receiver: receiver, arity: arity))
-      lines.append("return .undefined")
+      lines.append("return .undefined()")
     }
     return lines
   }
@@ -225,7 +225,7 @@ internal struct JSFunction {
   /// value as the primitive's `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
   /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
   /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
-  /// no-return function returns `.undefined` instead.
+  /// no-return function returns `.undefined()` instead.
   ///
   /// For an `async` function the encode must run on the JS thread. An `async` body may suspend and
   /// resume on an arbitrary cooperative-pool thread, and encoding a heap-allocated JS value (a string,
@@ -235,7 +235,7 @@ internal struct JSFunction {
   /// which always run on the JS thread — keep encoding directly without the wrapper.
   private func encodeResultLines() -> [String] {
     guard let returnType else {
-      return ["return .undefined"]
+      return ["return .undefined()"]
     }
     let encode = "try \(expressionType(returnType)).encode(result, in: runtime)"
     if isAsync {
@@ -309,7 +309,7 @@ internal struct JSProperty {
   /// function bindings: a module captures `self` strong, a shared object captures nothing of the
   /// instance. Getter and setter are gated independently.
   func decorateStatements(object: String, receiver: Receiver) -> String {
-    let descriptorName = "\(swiftName)Descriptor"
+    let descriptorName = derivedIdentifier(from: swiftName, suffix: "Descriptor")
     let callee = receiver.callee
     // A shared object's accessors unwrap the JS `this` into `_self` before reading/writing; a module
     // reads `self` directly. The unwrap leads each accessor body. Property accessors are synchronous, so
@@ -340,7 +340,7 @@ internal struct JSProperty {
       let setDecode = "\(callee).\(swiftName) = try \(decodeCall(valueType, from: "arguments.unownedValue(at: 0)"))"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined"))
+          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined()"))
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
@@ -437,7 +437,7 @@ internal func buildDecorateSharedObjectPhase(
 }
 
 /// True when a return clause is absent or written as `Void` / `()` — i.e. the function returns
-/// nothing JS-visible, so the binding returns `.undefined`.
+/// nothing JS-visible, so the binding returns `.undefined()`.
 private func isVoidType(_ type: TypeSyntax?) -> Bool {
   guard let type else {
     return true

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -91,9 +91,10 @@ extension EventMacro: PeerMacro {
       ? "func \(name)<P: \(jsConvertibleProtocolName), E: \(eventEmitterProtocolName)>(_: P.Type, _: E.Type) {}"
       : "func \(name)<E: \(eventEmitterProtocolName)>(_: E.Type) {}"
     let call = payload.map { "\(name)(\($0).self, \(owner).self)" } ?? "\(name)(\(owner).self)"
+    let peerName = derivedIdentifier(from: name, prefix: "_assertTypesConformance_")
     return [
       """
-      private func _assertTypesConformance_\(raw: name)() {
+      private func \(raw: peerName)() {
       \(raw: helper)
       \(raw: call)
       }
@@ -172,7 +173,7 @@ private func validatedEvent(
   let swiftName = identifier.identifier.text
   return EventMember(
     swiftName: swiftName,
-    jsName: jsNameArgument(of: node) ?? defaultEventName(for: swiftName),
+    jsName: jsNameArgument(of: node) ?? defaultEventName(for: withoutBackticks(swiftName)),
     payloadType: functionType.parameters.first?.type.trimmedDescription,
     isSync: boolArgument(of: node, label: "sync") == true
   )

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -45,7 +45,7 @@ public struct ExpoModuleMacro: MemberMacro {
     // class name) and emitted as a non-optional `_jsName` static below — so the
     // macro no longer emits a `Name(…)` DSL entry. Core reads the static for the module name,
     // ahead of its type-name fallback (which then only applies to non-macro DSL modules).
-    let moduleName = jsNameArgument(of: node) ?? classDecl.name.text
+    let moduleName = jsNameArgument(of: node) ?? withoutBackticks(classDecl.name.text)
     var entries: [String] = []
 
     // `@JS func`s (sync and async) and `@JS var`s are bound directly into the JS object by the

package/apple/Sources/ExpoModulesMacros/FreeFormTypes.swift

@@ -30,13 +30,16 @@ private let freeFormDecodeMethods: [String: String] = [
   "[String:Any]": "decodeAnyDictionary",
 ]
 
-/// The type-safe alternative a free-form type's diagnostic steers to: the same shape with the `Any`
-/// element replaced by `JavaScriptValue`, which conforms to the codable protocols. Keyed by the
-/// free-form type's normalized spelling; spelled with conventional spacing for the message.
+/// The type-safe alternative a free-form type's diagnostic steers to: the JS wrapper of the same shape
+/// (`JavaScriptArray` for an array, `JavaScriptObject` for a dictionary, `JavaScriptValue` for an
+/// untyped value). The wrappers conform to the codable protocols and keep the value unconverted; a
+/// non-copyable `JavaScriptValue` cannot be an element of a Swift array or dictionary, so the container
+/// shapes map to a wrapper rather than to a container of values. Keyed by the free-form type's
+/// normalized spelling.
 private let typedFreeFormReplacements: [String: String] = [
   "Any": "JavaScriptValue",
-  "[Any]": "[JavaScriptValue]",
-  "[String:Any]": "[String: JavaScriptValue]",
+  "[Any]": "JavaScriptArray",
+  "[String:Any]": "JavaScriptObject",
 ]
 
 /// True when a boundary type (as written) is one of the free-form spellings, ignoring internal
@@ -54,8 +57,8 @@ internal func freeFormDecodeMethod(for type: String) -> String? {
   return freeFormDecodeMethods[normalizedTypeSpelling(type)]
 }
 
-/// The type-safe alternative to suggest in place of a free-form type (its `Any` element replaced by
-/// `JavaScriptValue`), or `nil` when the type isn't free-form.
+/// The type-safe alternative to suggest in place of a free-form type (the JS wrapper of the same shape),
+/// or `nil` when the type isn't free-form.
 internal func typedFreeFormReplacement(for type: String) -> String? {
   return typedFreeFormReplacements[normalizedTypeSpelling(type)]
 }

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -51,7 +51,7 @@ internal struct JSConstructor {
   func buildConstructor(typeName: String) -> DeclSyntax {
     return """
       @JavaScriptActor
-      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
+      public override class func _constructSharedObject(this: borrowing JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
       \(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -31,6 +31,7 @@ public struct JSMacro: PeerMacro {
     providingPeersOf declaration: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
+    diagnoseParameterSpecifiers(in: declaration, in: context)
     diagnoseFreeFormTypes(in: declaration, in: context)
     diagnoseClosureTypes(in: declaration, in: context)
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
@@ -114,13 +115,46 @@ private func insertAsyncFixIt(for funcDecl: FunctionDeclSyntax) -> FixIt {
   )
 }
 
+/// Reports a function or constructor parameter whose specifier a decoded argument can't honor: an
+/// `inout` parameter expects its writes to reach the caller, and an `isolated` one expects an actor,
+/// while a `@JS` argument is a fresh value decoded from JavaScript. Ownership specifiers (`borrowing`,
+/// `consuming`, `sending`) are fine: the binding passes the decoded value under whichever convention
+/// the parameter asks for. The specifier is left off the decode and the assertion (see
+/// `SpecifiedType`); a parameter reported here is also left out of the assertion.
+private func diagnoseParameterSpecifiers(
+  in declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  let parameters: FunctionParameterListSyntax
+  if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
+    parameters = funcDecl.signature.parameterClause.parameters
+  } else if let initDecl = declaration.as(InitializerDeclSyntax.self) {
+    parameters = initDecl.signature.parameterClause.parameters
+  } else {
+    return
+  }
+  for parameter in parameters {
+    guard let specifier = SpecifiedType(parameter.type).unsupportedSpecifier else {
+      continue
+    }
+    context.diagnose(
+      Diagnostic(
+        node: parameter.type,
+        message: JSDiagnosticMessage(
+          "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
+        )))
+  }
+}
+
 /// Emits the free-form (`Any` / `[Any]` / `[String: Any]`) diagnostics for a `@JS` declaration.
 ///
 /// A free-form type is only supported crossing the boundary as an **argument**, decoded through
 /// `JavaScriptValue.decodeAny…`; there is no free-form encode, so any position that encodes is a hard
 /// error. That means:
 /// - a function/constructor **parameter** typed free-form gets a warning steering to
-///   `[String: JavaScriptValue]` (the type-safe alternative), but compiles;
+///   `JavaScriptValue` (the type-safe alternative), but compiles;
 /// - a function **return** typed free-form is an error (it would need to encode);
 /// - a **property** typed free-form is an error regardless of settability, because its getter always
 ///   encodes.
@@ -156,9 +190,8 @@ private func diagnoseFreeFormTypes(
   }
 }
 
-/// The tail of a free-form encode error: the reshaped `JavaScriptValue` alternative when the type is a
-/// container (`[String: Any]` -> `[String: JavaScriptValue]`), otherwise the passthrough suggestion
-/// for a bare `Any`. Both conform to the codable protocols, so either is a valid fix.
+/// The tail of a free-form encode error: the typed wrapper of the same shape (`JavaScriptArray`,
+/// `JavaScriptObject`) when there is one, otherwise the plain `JavaScriptValue` passthrough suggestion.
 private func suggestedAlternative(for freeFormType: String) -> String {
   if let reshaped = typedFreeFormReplacement(for: freeFormType), reshaped != "JavaScriptValue" {
     return "Use '\(reshaped)', or 'JavaScriptValue' to pass a JS value through unchanged."
@@ -173,7 +206,8 @@ private func warnFreeFormArguments(
   in context: some MacroExpansionContext
 ) {
   for parameter in parameters {
-    let type = parameter.type.trimmedDescription
+    // Matched on the bare type: `borrowing [String: Any]` decodes as free-form too.
+    let type = SpecifiedType(parameter.type).type.trimmedDescription
     guard let suggested = typedFreeFormReplacement(for: type) else {
       continue
     }
@@ -189,7 +223,7 @@ private func freeFormArgumentWarning(
   suggesting suggestedType: String
 ) -> JSDiagnosticMessage {
   return JSDiagnosticMessage(
-    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); the 'JavaScriptValue' element keeps each value inspectable without erasing it.",
+    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); '\(suggestedType)' keeps the JS value inspectable without converting it.",
     id: "js-free-form-argument",
     severity: .warning
   )
@@ -266,9 +300,15 @@ private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> Boundary
     var decodableTypes: [String] = []
     var callbackArgumentTypes: [String] = []
     for parameter in funcDecl.signature.parameterClause.parameters {
-      guard let closure = JSClosureType(parameter.type) else {
-        if !containsFunctionType(parameter.type) {
-          decodableTypes.append(parameter.type.trimmedDescription)
+      // 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) {
+          decodableTypes.append(specified.type.trimmedDescription)
         }
         continue
       }

package/apple/Sources/ExpoModulesMacros/MacroHelpers.swift

@@ -72,6 +72,9 @@ internal func isConcurrentJSMember(_ decl: DeclSyntaxProtocol) -> Bool {
 /// True if the type is written as an optional: `T?`, `T!`, or the explicit `Optional<T>`. Used to
 /// decide argument requiredness (an optional parameter may be omitted) and record-field nullability.
 internal func isOptionalType(_ type: TypeSyntax) -> Bool {
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isOptionalType(attributed.baseType)
+  }
   if type.is(OptionalTypeSyntax.self) || type.is(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
     return true
   }
@@ -81,6 +84,39 @@ internal func isOptionalType(_ type: TypeSyntax) -> Bool {
   return false
 }
 
+/// A parameter's type split from the specifiers written in front of it (`borrowing`, `consuming`,
+/// `sending`, `inout`, `isolated`, ...). The specifiers aren't part of the type: the decode call and
+/// the conformance assertion need the bare type (`borrowing Point.decode(...)` isn't valid Swift), and
+/// a decoded argument is a fresh owned value, so it can be passed under any ownership convention.
+internal struct SpecifiedType {
+  /// The type without its specifiers.
+  let type: TypeSyntax
+  /// The specifiers written before the type, in source order.
+  let specifiers: [String]
+
+  init(_ type: TypeSyntax) {
+    if let attributed = type.as(AttributedTypeSyntax.self), !attributed.specifiers.isEmpty {
+      self.specifiers = attributed.specifiers.map(\.trimmedDescription)
+      self.type =
+        attributed.attributes.isEmpty
+        ? attributed.baseType : TypeSyntax(attributed.with(\.specifiers, []))
+    } else {
+      self.specifiers = []
+      self.type = type
+    }
+  }
+
+  /// The first specifier a decoded argument can't honor: `inout` (JavaScript can't observe a write
+  /// back) or `isolated` (the argument doesn't carry an isolation).
+  var unsupportedSpecifier: String? {
+    return specifiers.first { !ownershipSpecifiers.contains($0) }
+  }
+}
+
+/// The ownership specifiers a parameter may carry. They only change how the argument is passed, which
+/// a fresh decoded value satisfies either way.
+internal let ownershipSpecifiers: Set<String> = ["borrowing", "consuming", "sending", "__shared", "__owned"]
+
 /// The type wrapped by one optional layer (`T?`, `T!` or `Optional<T>`), or `nil` when the type isn't
 /// optional.
 internal func optionalWrappedType(_ type: TypeSyntax) -> TypeSyntax? {
@@ -341,6 +377,32 @@ internal func decodeCall(_ type: String, from valueExpression: String) -> String
   return "\(expressionType(type)).decode(\(valueExpression), in: runtime)"
 }
 
+// MARK: - Escaped names
+
+/// `name` without the backticks that escape it: `` `default` `` becomes `default`. Swift needs the
+/// backticks in every identifier position, but a name JavaScript sees (a JS member name, an event
+/// name, a record key) is the bare name.
+internal func withoutBackticks(_ name: String) -> String {
+  var name = Substring(name)
+  while name.first == "`" {
+    name.removeFirst()
+  }
+  while name.last == "`" {
+    name.removeLast()
+  }
+  return String(name)
+}
+
+/// A generated identifier built from a member's name, such as `countDescriptor` from `count`. The
+/// affixes join the bare name, and an escaped name keeps the backticks around the whole result
+/// (`` `class` `` gives `` `classDescriptor` ``), since the bare name may not be an identifier on
+/// its own.
+internal func derivedIdentifier(from name: String, prefix: String = "", suffix: String = "") -> String {
+  let bareName = withoutBackticks(name)
+  let identifier = prefix + bareName + suffix
+  return bareName == name ? identifier : "`\(identifier)`"
+}
+
 // MARK: - @JS property collection
 
 /// Collects the `@JS var` bindings of a declaration into `JSProperty` values for direct JSI binding.
@@ -365,7 +427,7 @@ internal func collectProperties(
       ?? binding.initializer.flatMap { inferredLiteralType(of: $0.value) }
     return JSProperty(
       swiftName: swiftName,
-      jsName: jsNameOverride ?? swiftName,
+      jsName: jsNameOverride ?? withoutBackticks(swiftName),
       valueType: valueType,
       isSettable: isVar && bindingIsSettable(binding)
     )

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -95,7 +95,7 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
         members.append(defaultInit)
       }
     }
-    if !existingInitLabels.contains(properties.map { $0.name }) {
+    if !existingInitLabels.contains(properties.map { $0.key }) {
       members.append(memberwiseInit(properties: properties))
     }
     members.append(fromJSObjectFactory(properties: properties))
@@ -195,10 +195,11 @@ private enum FreeFormConversion {
 
 /**
  A single record property discovered on the type, paired with everything the synthesized
- conversions need: its property name (also the JS key), its written type, and how the
- source may omit it.
+ conversions need: its property name, its written type, and how the source may omit it.
  */
 private struct RecordProperty {
+  /// The property name as written, backticks included for an escaped name (`` `default` ``), since
+  /// every identifier position in the generated code needs them.
   let name: String
   /// The property's declared type, verbatim (e.g. `String`, `Int`, `String?`). Used to build the
   /// memberwise-init parameter and as the receiver of the per-property `decode`/`encode` (and, on the
@@ -222,6 +223,12 @@ private struct RecordProperty {
   var isRequired: Bool {
     return !hasDefault && !isOptional
   }
+
+  /// The key the property reads from and writes to, in both the JS object and the dictionary: the
+  /// name without escaping backticks.
+  var key: String {
+    return withoutBackticks(name)
+  }
 }
 
 /**
@@ -414,7 +421,7 @@ private func factoryBody(properties: [RecordProperty], readLines: [String]) -> S
 private func jsObjectReadLines(properties: [RecordProperty]) -> [String] {
   var lines: [String] = []
   for property in properties {
-    let valueVar = "\(property.name)JSValue"
+    let valueVar = derivedIdentifier(from: property.name, suffix: "JSValue")
     let exprType = expressionType(property.type)
     let decode: String
     switch property.freeForm {
@@ -426,10 +433,10 @@ private func jsObjectReadLines(properties: [RecordProperty]) -> [String] {
     case nil:
       decode = "try \(exprType).decode(\(valueVar), in: runtime)"
     }
-    lines.append("  let \(valueVar) = object.getProperty(\"\(property.name)\")")
+    lines.append("  let \(valueVar) = object.getProperty(\"\(property.key)\")")
     if property.isRequired {
       lines.append("  guard !\(valueVar).isUndefined() else {")
-      lines.append("    throw RecordPropertyRequiredException(\"\(property.name)\")")
+      lines.append("    throw RecordPropertyRequiredException(\"\(property.key)\")")
       lines.append("  }")
       lines.append("  let \(property.name) = \(decode)")
     } else if property.isOptional {
@@ -449,16 +456,16 @@ private func jsObjectReadLines(properties: [RecordProperty]) -> [String] {
 private func dictionaryReadLines(properties: [RecordProperty]) -> [String] {
   var lines: [String] = []
   for property in properties {
-    let valueVar = "\(property.name)Value"
+    let valueVar = derivedIdentifier(from: property.name, suffix: "Value")
     let exprType = expressionType(property.type)
     let isBareAny = property.freeForm?.isBareAny == true
     let cast = isBareAny
       ? valueVar
       : "try \(exprType).getDynamicType().cast(\(valueVar), appContext: appContext) as! \(exprType)"
-    lines.append("  let \(valueVar) = dictionary[\"\(property.name)\"]")
+    lines.append("  let \(valueVar) = dictionary[\"\(property.key)\"]")
     if property.isRequired {
       lines.append("  guard let \(valueVar) else {")
-      lines.append("    throw RecordPropertyRequiredException(\"\(property.name)\")")
+      lines.append("    throw RecordPropertyRequiredException(\"\(property.key)\")")
       lines.append("  }")
       lines.append("  let \(property.name) = \(cast)")
     } else if property.isOptional {
@@ -483,7 +490,7 @@ private func toDictionaryMethod(properties: [RecordProperty], inheritsRecord: Bo
     lines.append("  var dictionary: [String: Any] = [:]")
   }
   for property in properties {
-    lines.append("  dictionary[\"\(property.name)\"] = self.\(property.name)")
+    lines.append("  dictionary[\"\(property.key)\"] = self.\(property.name)")
   }
   lines.append("  return dictionary")
   let body = lines.joined(separator: "\n")
@@ -529,7 +536,7 @@ private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool)
     switch property.freeForm {
     case .shape(_, let encodeMethod, let isOptional, _):
       encode = isOptional
-        ? "self.\(property.name) == nil ? .null : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
+        ? "self.\(property.name) == nil ? .null() : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
         : "try JavaScriptValue.\(encodeMethod)(self.\(property.name), in: runtime)"
     case .generic:
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.
@@ -537,7 +544,7 @@ private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool)
     case nil:
       encode = "try \(exprType).encode(self.\(property.name), in: runtime)"
     }
-    lines.append("  object.setProperty(\"\(property.name)\", value: \(encode))")
+    lines.append("  object.setProperty(\"\(property.key)\", value: \(encode))")
   }
   lines.append("  return object")
   let body = lines.joined(separator: "\n")
@@ -567,7 +574,7 @@ private func initializerParameterLabels(of declaration: some DeclGroupSyntax) ->
     }
     let labels = initDecl.signature.parameterClause.parameters.map { parameter in
       // `firstName` is the external label (or `_`); fall back to the internal name when omitted.
-      let label = parameter.firstName.text
+      let label = withoutBackticks(parameter.firstName.text)
       return label == "_" ? "" : label
     }
     signatures.append(labels)

package/apple/Sources/ExpoModulesMacros/SharedObjectMacro.swift

@@ -39,7 +39,7 @@ public struct SharedObjectMacro: MemberMacro {
     }
 
     let typeName = classDecl.name.text
-    let jsName = jsNameArgument(of: node) ?? typeName
+    let jsName = jsNameArgument(of: node) ?? withoutBackticks(typeName)
 
     // `@JS func`s/`var`s and the `@JS init` are bound directly into the shared object's JS object by
     // the synthesized `_decorateSharedObject(prototype:)` / `_decorateSharedObject(constructor:)` / `_constructSharedObject`

package/apple/Sources/ExpoModulesMacros/TypeConformanceAssertion.swift

@@ -111,8 +111,9 @@ internal func directionalConformanceAssertion(
   let helper = "func \(name)<\(parameters.joined(separator: ", "))>(\(typeParameters.joined(separator: ", "))) {}"
   let call = "\(name)(\(arguments.joined(separator: ", ")))"
   let staticKeyword = isStatic ? "static " : ""
+  let peerName = derivedIdentifier(from: name, prefix: "_assertTypesConformance_")
   return """
-    private \(raw: staticKeyword)func _assertTypesConformance_\(raw: name)() {
+    private \(raw: staticKeyword)func \(raw: peerName)() {
     \(raw: helper)
     \(raw: call)
     }

package/apple/Sources/ExpoModulesMacros/ViewPropsMacro.swift

@@ -251,18 +251,6 @@ private struct ViewProp {
   }
 }
 
-/// `name` without the backticks that escape it: `` `default` `` becomes `default`.
-private func withoutBackticks(_ name: String) -> String {
-  var name = Substring(name)
-  while name.first == "`" {
-    name.removeFirst()
-  }
-  while name.last == "`" {
-    name.removeLast()
-  }
-  return String(name)
-}
-
 private struct ViewPropsModel {
   /// Value props, in declaration order. The order is the bit order, so it is part of the ABI
   /// between a compiled view and the runtime that fills the mask.

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

@@ -20,7 +20,7 @@ final class SurfaceVisitor: SyntaxVisitor {
 
   override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
     if isTopLevel(node) {
-      classify(name: node.name.text, attributes: node.attributes, members: node.memberBlock.members)
+      classify(name: node.name.identifierName, attributes: node.attributes, members: node.memberBlock.members)
     }
     // The member walk reads the body itself; nested types aren't part of this surface (matching
     // `DetectionVisitor`'s top-level-only scope), so there's no reason to descend.
@@ -29,7 +29,7 @@ final class SurfaceVisitor: SyntaxVisitor {
 
   override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
     if isTopLevel(node) {
-      classify(name: node.name.text, attributes: node.attributes, members: node.memberBlock.members)
+      classify(name: node.name.identifierName, attributes: node.attributes, members: node.memberBlock.members)
     }
     return .skipChildren
   }
@@ -48,7 +48,7 @@ final class SurfaceVisitor: SyntaxVisitor {
     if node.attributes.firstAttribute(named: DetectedMacro.union.rawValue) != nil {
       unions.append(
         ExportedUnion(
-          name: node.name.text,
+          name: node.name.identifierName,
           members: collectUnionMembers(node.memberBlock.members),
           file: file
         ))
@@ -56,7 +56,7 @@ final class SurfaceVisitor: SyntaxVisitor {
       let rawType = rawValueType(of: node.inheritanceClause)
       enums.append(
         ExportedEnum(
-          name: node.name.text,
+          name: node.name.identifierName,
           rawType: rawType,
           cases: collectEnumCases(node.memberBlock.members, rawType: rawType),
           file: file
@@ -178,7 +178,7 @@ final class SurfaceVisitor: SyntaxVisitor {
         functionType.parameters.count <= 1 else {
         continue
       }
-      let name = ident.identifier.text
+      let name = ident.identifier.identifierName
       result.append(
         ExportedEvent(
           name: name,
@@ -196,8 +196,8 @@ final class SurfaceVisitor: SyntaxVisitor {
     let effects = funcDecl.signature.effectSpecifiers
     let returnType = funcDecl.signature.returnClause?.type
     return ExportedFunction(
-      name: funcDecl.name.text,
-      jsName: stringArgument(of: attribute) ?? funcDecl.name.text,
+      name: funcDecl.name.identifierName,
+      jsName: stringArgument(of: attribute) ?? funcDecl.name.identifierName,
       parameters: parameters(of: funcDecl.signature.parameterClause),
       returns: isVoidType(returnType) ? nil : returnType.map { typeNode(from: $0) },
       isAsync: effects?.asyncSpecifier != nil,
@@ -219,7 +219,7 @@ final class SurfaceVisitor: SyntaxVisitor {
       guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
         continue
       }
-      let name = ident.identifier.text
+      let name = ident.identifier.identifierName
       let type = valueTypeNode(annotation: binding.typeAnnotation?.type, initializer: binding.initializer?.value)
       result.append(
         ExportedProperty(
@@ -284,7 +284,7 @@ final class SurfaceVisitor: SyntaxVisitor {
         }
         properties.append(
           ExportedRecordProperty(
-            name: ident.identifier.text,
+            name: ident.identifier.identifierName,
             type: type,
             isOptional: annotation.map { isOptionalType($0) } ?? false,
             hasDefault: binding.initializer != nil
@@ -312,7 +312,7 @@ final class SurfaceVisitor: SyntaxVisitor {
         continue
       }
       for element in caseDecl.elements where element.parameterClause == nil {
-        let name = element.name.text
+        let name = element.name.identifierName
         cases.append(
           ExportedEnumCase(
             name: name,
@@ -343,7 +343,7 @@ final class SurfaceVisitor: SyntaxVisitor {
           continue
         }
         result.append(
-          ExportedUnionMember(name: element.name.text, type: typeNode(from: parameter.type)))
+          ExportedUnionMember(name: element.name.identifierName, type: typeNode(from: parameter.type)))
       }
     }
     return result
@@ -353,8 +353,8 @@ final class SurfaceVisitor: SyntaxVisitor {
   /// first), and `optional` when it has a default value or an optional type.
   private func parameters(of clause: FunctionParameterClauseSyntax) -> [ExportedParameter] {
     clause.parameters.map { parameter in
-      let label = parameter.firstName.text
-      let name = parameter.secondName?.text ?? label
+      let label = parameter.firstName.identifierName
+      let name = parameter.secondName?.identifierName ?? label
       return ExportedParameter(
         label: label,
         name: name,
@@ -376,6 +376,15 @@ final class SurfaceVisitor: SyntaxVisitor {
 
 // MARK: - Syntactic helpers (shared spelling with the macros)
 
+extension TokenSyntax {
+  /// The name a token spells, without the backticks Swift requires around a reserved word used as
+  /// a name: `` `default` `` reads as `default`. Tokens that aren't identifiers, such as the `_`
+  /// wildcard label, read as written.
+  var identifierName: String {
+    identifier?.name ?? text
+  }
+}
+
 /// True when the modifiers make a member type-level (`static` or `class`).
 // MARK: - `@Event` helpers
 

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

@@ -204,7 +204,7 @@ func typeNode(from type: TypeSyntax) -> TypeNode {
   }
   // A nominal type, possibly generic: `Int`, `Point`, `Optional<T>`, `Array<T>`, `Promise<T>`.
   if let identifier = type.as(IdentifierTypeSyntax.self) {
-    return nominalNode(name: identifier.name.text, generics: identifier.genericArgumentClause)
+    return nominalNode(name: identifier.name.identifierName, generics: identifier.genericArgumentClause)
   }
   // A qualified nominal type: `Foo.Bar`. Kept as a ref under its full spelling.
   if let member = type.as(MemberTypeSyntax.self) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.17.0-0",
+  "version": "0.18.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-win32-arm64": "0.17.0-0",
-    "@expo/modules-macros-win32-x64": "0.17.0-0"
+    "@expo/modules-macros-win32-arm64": "0.18.0",
+    "@expo/modules-macros-win32-x64": "0.18.0"
   }
 }