BridgeJS: Add importParams, NilSentinel, sentinel-based optional lowering, and collapse liftExpression

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -717,13 +717,8 @@ struct StackCodegen {
     /// - Returns: An ExprSyntax representing the lift expression
     func liftExpression(for type: BridgeType) -> ExprSyntax {
         switch type {
-        case .string, .int, .uint, .bool, .float, .double,
-            .jsObject(nil), .jsValue, .swiftStruct, .swiftHeapObject, .unsafePointer,
-            .swiftProtocol, .caseEnum, .associatedValueEnum, .rawValueEnum:
-            return "\(raw: type.swiftType).bridgeJSLiftParameter()"
         case .jsObject(let className?):
             return "\(raw: className)(unsafelyWrapping: JSObject.bridgeJSLiftParameter())"
-
         case .nullable(let wrappedType, let kind):
             return liftNullableExpression(wrappedType: wrappedType, kind: kind)
         case .array(let elementType):
@@ -734,6 +729,8 @@ struct StackCodegen {
             return "JSObject.bridgeJSLiftParameter()"
         case .void, .namespaceEnum:
             return "()"
+        default:
+            return "\(raw: type.swiftType).bridgeJSLiftParameter()"
         }
     }
 

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -719,18 +719,7 @@ extension BridgeType {
     }
 
     private func loweringParameterInfoForNonOptional(context: BridgeContext) throws -> LoweringParameterInfo {
-        switch self {
-        case .swiftStruct where context == .importTS:
-            return LoweringParameterInfo(loweredParameters: [("objectId", .i32)])
-        case .string:
-            return LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        case .rawValueEnum(_, .string):
-            return LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        default:
-            break
-        }
-
-        return LoweringParameterInfo(loweredParameters: descriptor.wasmParams)
+        return LoweringParameterInfo(loweredParameters: descriptor.importParams)
     }
 
     struct LiftingReturnInfo {
@@ -759,14 +748,6 @@ extension BridgeType {
     }
 
     private func liftingReturnInfoForNonOptional(context: BridgeContext) -> LiftingReturnInfo {
-        if context == .importTS {
-            switch self {
-            case .swiftStruct:
-                return LiftingReturnInfo(valueToLift: .i32)
-            default:
-                break
-            }
-        }
         return LiftingReturnInfo(valueToLift: descriptor.importReturnType)
     }
 }

Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift

@@ -1113,6 +1113,15 @@ struct IntrinsicJSFragment: Sendable {
             )
         }
 
+        if desc.nilSentinel.hasSentinel {
+            let innerFragment = try lowerReturn(type: wrappedType, context: .exportSwift)
+            return sentinelOptionalLowerReturn(
+                wrappedType: wrappedType,
+                kind: kind,
+                innerFragment: innerFragment
+            )
+        }
+
         return IntrinsicJSFragment(
             parameters: ["value"],
             printCode: { arguments, context in
@@ -1123,8 +1132,6 @@ struct IntrinsicJSFragment: Sendable {
                 printer.write("const \(isSomeVar) = \(presenceExpr);")
 
                 switch wrappedType {
-                case .caseEnum:
-                    printer.write("return \(isSomeVar) ? (\(value) | 0) : -1;")
                 case .string, .rawValueEnum(_, .string):
                     printer.write("if (\(isSomeVar)) {")
                     printer.indent {
@@ -1155,8 +1162,6 @@ struct IntrinsicJSFragment: Sendable {
                         scope.emitPushF64Parameter(payload2Var, printer: printer)
                     }
                     scope.emitPushI32Parameter("\(isSomeVar) ? 1 : 0", printer: printer)
-                case .swiftHeapObject:
-                    printer.write("return \(isSomeVar) ? \(value).pointer : 0;")
                 case .array(let elementType):
                     printer.write("if (\(isSomeVar)) {")
                     try printer.indent {
@@ -1174,21 +1179,6 @@ struct IntrinsicJSFragment: Sendable {
                     }
                     printer.write("}")
                     scope.emitPushI32Parameter("\(isSomeVar) ? 1 : 0", printer: printer)
-                case .associatedValueEnum(let fullName):
-                    let base = fullName.components(separatedBy: ".").last ?? fullName
-                    let caseIdVar = scope.variable("caseId")
-                    printer.write("if (\(isSomeVar)) {")
-                    printer.indent {
-                        printer.write(
-                            "const { caseId: \(caseIdVar) } = \(JSGlueVariableScope.reservedEnumHelpers).\(base).lower(\(value));"
-                        )
-                        printer.write("return \(caseIdVar);")
-                    }
-                    printer.write("} else {")
-                    printer.indent {
-                        printer.write("return -1;")
-                    }
-                    printer.write("}")
                 case .dictionary(let valueType):
                     printer.write("if (\(isSomeVar)) {")
                     try printer.indent {
@@ -1217,6 +1207,81 @@ struct IntrinsicJSFragment: Sendable {
         )
     }
 
+    private static func sentinelOptionalLowerReturn(
+        wrappedType: BridgeType,
+        kind: JSOptionalKind,
+        innerFragment: IntrinsicJSFragment
+    ) -> IntrinsicJSFragment {
+        let desc = wrappedType.descriptor
+        let sentinelLiteral = desc.nilSentinel.jsLiteral
+
+        return IntrinsicJSFragment(
+            parameters: ["value"],
+            printCode: { arguments, context in
+                let (scope, printer, cleanupCode) = (context.scope, context.printer, context.cleanupCode)
+                let value = arguments[0]
+                let isSomeVar = scope.variable("isSome")
+                let presenceExpr = kind.presenceCheck(value: value)
+                printer.write("const \(isSomeVar) = \(presenceExpr);")
+
+                let bufferPrinter = CodeFragmentPrinter()
+                let innerCleanup = CodeFragmentPrinter()
+                let innerResults = try innerFragment.printCode(
+                    [value],
+                    context.with(\.printer, bufferPrinter).with(\.cleanupCode, innerCleanup)
+                )
+
+                let hasSideEffects = !bufferPrinter.lines.isEmpty
+                let innerExpr = innerResults.first
+
+                let innerCleanupLines = innerCleanup.lines.filter {
+                    !$0.trimmingCharacters(in: .whitespaces).isEmpty
+                }
+                if !innerCleanupLines.isEmpty {
+                    let cleanupVar = scope.variable("\(value)Cleanup")
+                    printer.write("let \(cleanupVar);")
+                    printer.write("if (\(isSomeVar)) {")
+                    printer.indent {
+                        for line in bufferPrinter.lines {
+                            printer.write(line)
+                        }
+                        printer.write("\(cleanupVar) = () => {")
+                        printer.indent {
+                            for line in innerCleanupLines {
+                                printer.write(line)
+                            }
+                        }
+                        printer.write("};")
+                    }
+                    printer.write("}")
+                    if let expr = innerExpr {
+                        printer.write("return \(isSomeVar) ? \(expr) : \(sentinelLiteral);")
+                    }
+                    cleanupCode.write("if (\(cleanupVar)) { \(cleanupVar)(); }")
+                } else if hasSideEffects {
+                    printer.write("if (\(isSomeVar)) {")
+                    printer.indent {
+                        for line in bufferPrinter.lines {
+                            printer.write(line)
+                        }
+                        if let expr = innerExpr {
+                            printer.write("return \(expr);")
+                        }
+                    }
+                    printer.write("} else {")
+                    printer.indent {
+                        printer.write("return \(sentinelLiteral);")
+                    }
+                    printer.write("}")
+                } else if let expr = innerExpr {
+                    printer.write("return \(isSomeVar) ? \(expr) : \(sentinelLiteral);")
+                }
+
+                return []
+            }
+        )
+    }
+
     // MARK: - Protocol Support
 
     static func protocolPropertyOptionalToSideChannel(wrappedType: BridgeType) throws -> IntrinsicJSFragment {

Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift

@@ -200,6 +200,33 @@ public enum OptionalConvention: Sendable, Equatable {
     case sideChannelReturn
 }
 
+/// A bit pattern that is never a valid value for a type, usable to represent `nil`
+/// without an extra `isSome` flag. Inspired by Swift's "extra inhabitant" concept.
+///
+/// Types with a nil sentinel can encode Optional<T> in T's own return slot:
+/// the sentinel value means absent, any other value means present.
+/// Types without a sentinel need either an inline isSome flag or a side channel.
+public enum NilSentinel: Sendable, Equatable {
+    /// No sentinel exists - all bit patterns are valid values.
+    case none
+    /// A specific i32 value is never valid (e.g. 0 for object IDs, -1 for enum tags).
+    case i32(Int32)
+    /// A null pointer (0) is the sentinel.
+    case pointer
+
+    public var jsLiteral: String {
+        switch self {
+        case .none: fatalError("No sentinel value for .none")
+        case .i32(let value): return "\(value)"
+        case .pointer: return "0"
+        }
+    }
+
+    public var hasSentinel: Bool {
+        self != .none
+    }
+}
+
 /// Captures the WASM ABI shape for a ``BridgeType`` so codegen can read descriptor fields
 /// instead of switching on every concrete type.
 ///
@@ -208,33 +235,32 @@ public enum OptionalConvention: Sendable, Equatable {
 /// import side returns a pointer/ID while the export side uses the stack.
 public struct BridgeTypeDescriptor: Sendable {
     public let wasmParams: [(name: String, type: WasmCoreType)]
+    public let importParams: [(name: String, type: WasmCoreType)]
     public let wasmReturnType: WasmCoreType?
     public let importReturnType: WasmCoreType?
     public let optionalConvention: OptionalConvention
+    public let nilSentinel: NilSentinel
     public let usesStackLifting: Bool
     public let accessorTransform: AccessorTransform
     public let lowerMethod: LowerMethod
 
-    /// Creates a descriptor with an explicitly specified optional convention.
-    ///
-    /// When `optionalConvention` is nil, it is derived from `wasmParams`:
-    /// - Empty `wasmParams` (stack-based types) default to `.stackABI`
-    /// - Non-empty `wasmParams` (scalar types) default to `.inlineFlag`
-    ///
-    /// Only `.sideChannelReturn` needs to be explicitly specified.
     public init(
         wasmParams: [(name: String, type: WasmCoreType)],
+        importParams: [(name: String, type: WasmCoreType)]? = nil,
         wasmReturnType: WasmCoreType?,
         importReturnType: WasmCoreType?? = nil,
         optionalConvention: OptionalConvention? = nil,
+        nilSentinel: NilSentinel = .none,
         usesStackLifting: Bool = false,
         accessorTransform: AccessorTransform,
         lowerMethod: LowerMethod
     ) {
         self.wasmParams = wasmParams
+        self.importParams = importParams ?? wasmParams
         self.wasmReturnType = wasmReturnType
         self.importReturnType = importReturnType ?? wasmReturnType
         self.optionalConvention = optionalConvention ?? (wasmParams.isEmpty ? .stackABI : .inlineFlag)
+        self.nilSentinel = nilSentinel
         self.usesStackLifting = usesStackLifting
         self.accessorTransform = accessorTransform
         self.lowerMethod = lowerMethod
@@ -356,6 +382,7 @@ extension BridgeType {
         case .string:
             return BridgeTypeDescriptor(
                 wasmParams: [("bytes", .i32), ("length", .i32)],
+                importParams: [("value", .i32)],
                 wasmReturnType: nil,
                 importReturnType: .i32,
                 optionalConvention: .sideChannelReturn,
@@ -369,6 +396,7 @@ extension BridgeType {
                 wasmParams: [("value", .i32)],
                 wasmReturnType: .i32,
                 optionalConvention: .sideChannelReturn,
+                nilSentinel: .i32(0),
                 accessorTransform: transform,
                 lowerMethod: .stackReturn
             )
@@ -383,6 +411,7 @@ extension BridgeType {
             return BridgeTypeDescriptor(
                 wasmParams: [("pointer", .pointer)],
                 wasmReturnType: .pointer,
+                nilSentinel: .pointer,
                 accessorTransform: .identity,
                 lowerMethod: .stackReturn
             )
@@ -398,13 +427,15 @@ extension BridgeType {
                 wasmParams: [("value", .i32)],
                 wasmReturnType: .i32,
                 optionalConvention: .sideChannelReturn,
+                nilSentinel: .i32(0),
                 accessorTransform: .cast("Any\(protocolName)"),
                 lowerMethod: .stackReturn
             )
         case .caseEnum:
             return BridgeTypeDescriptor(
                 wasmParams: [("value", .i32)],
                 wasmReturnType: .i32,
+                nilSentinel: .i32(-1),
                 accessorTransform: .identity,
                 lowerMethod: .stackReturn
             )
@@ -413,6 +444,7 @@ extension BridgeType {
             case .string:
                 return BridgeTypeDescriptor(
                     wasmParams: [("bytes", .i32), ("length", .i32)],
+                    importParams: [("value", .i32)],
                     wasmReturnType: nil,
                     importReturnType: .some(.i32),
                     optionalConvention: .sideChannelReturn,
@@ -456,6 +488,7 @@ extension BridgeType {
                 wasmParams: [("caseId", .i32)],
                 wasmReturnType: nil,
                 importReturnType: .i32,
+                nilSentinel: .i32(-1),
                 usesStackLifting: true,
                 accessorTransform: .identity,
                 lowerMethod: .pushParameter
@@ -470,7 +503,9 @@ extension BridgeType {
         case .swiftStruct:
             return BridgeTypeDescriptor(
                 wasmParams: [],
+                importParams: [("objectId", .i32)],
                 wasmReturnType: nil,
+                importReturnType: .i32,
                 usesStackLifting: true,
                 accessorTransform: .identity,
                 lowerMethod: .fullReturn

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Protocol.js

@@ -428,7 +428,7 @@ export async function createInstantiator(options, swift) {
                 try {
                     let ret = swift.memory.getObject(self).directionOptional;
                     const isSome = ret != null;
-                    return isSome ? (ret | 0) : -1;
+                    return isSome ? ret : -1;
                 } catch (error) {
                     setException(error);
                 }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClosure.js

@@ -745,7 +745,7 @@ export async function createInstantiator(options, swift) {
                     const callback = swift.memory.getObject(callbackId);
                     let ret = callback(param0IsSome ? param0WrappedValue : null);
                     const isSome = ret != null;
-                    return isSome ? (ret | 0) : -1;
+                    return isSome ? ret : -1;
                 } catch (error) {
                     setException(error);
                 }