BridgeJS: Remove insertion of bridging calls for aliases

Author: wfltaylor

Plugins/BridgeJS/Sources/BridgeJSCore/ClosureCodegen.swift

@@ -153,8 +153,9 @@ public struct ClosureCodegen {
             let argNames = liftInfo.parameters.map { (argName, _) in
                 liftInfo.parameters.count > 1 ? "\(paramName)\(argName.capitalizedFirstLetter)" : paramName
             }
-            let liftCall = "\(paramType.unaliased.swiftType).bridgeJSLiftParameter(\(argNames.joined(separator: ", ")))"
-            liftedParams.append(paramType.liftAliases(expression: liftCall))
+            liftedParams.append(
+                "\(paramType.swiftType).bridgeJSLiftParameter(\(argNames.joined(separator: ", ")))"
+            )
         }
 
         let tryPrefix = signature.isThrows ? "try " : ""
@@ -198,8 +199,7 @@ public struct ClosureCodegen {
                     }
                     printer.write("}")
                 default:
-                    let lowered = signature.returnType.lowerAliases(expression: "result")
-                    printer.write("return \(lowered).bridgeJSLowerReturn()")
+                    printer.write("return result.bridgeJSLowerReturn()")
                 }
             }
         }

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -100,6 +100,15 @@ public class ExportSwift {
                 }
             }
         }
+
+        withSpan("Render Aliases") { [self] in
+            let aliasCodegen = AliasCodegen()
+            for alias in skeleton.aliases {
+                if let aliasExtension = aliasCodegen.renderAliasConformance(alias) {
+                    decls.append(aliasExtension)
+                }
+            }
+        }
         return withSpan("Format Export Glue") {
             return decls.map { $0.description }.joined(separator: "\n\n")
         }
@@ -227,15 +236,15 @@ public class ExportSwift {
                 } else {
                     optionalSwiftType = "JSUndefinedOr"
                 }
-                typeNameForIntrinsic = "\(optionalSwiftType)<\(wrappedType.unaliased.swiftType)>"
-                let liftCall =
-                    "\(typeNameForIntrinsic).bridgeJSLiftParameter(\(argumentsToLift.joined(separator: ", ")))"
-                liftingExpr = "\(raw: param.type.liftAliases(expression: liftCall))"
+                typeNameForIntrinsic = "\(optionalSwiftType)<\(wrappedType.swiftType)>"
+                liftingExpr = ExprSyntax(
+                    "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
+                )
             default:
-                typeNameForIntrinsic = param.type.unaliased.swiftType
-                let liftCall =
-                    "\(typeNameForIntrinsic).bridgeJSLiftParameter(\(argumentsToLift.joined(separator: ", ")))"
-                liftingExpr = "\(raw: param.type.liftAliases(expression: liftCall))"
+                typeNameForIntrinsic = param.type.swiftType
+                liftingExpr = ExprSyntax(
+                    "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
+                )
             }
 
             liftedParameterExprs.append(liftingExpr)
@@ -280,8 +289,7 @@ public class ExportSwift {
             }
 
             if effects.isAsync, returnType != .void {
-                let lowered = returnType.lowerAliases(expression: callExpr.description)
-                return CodeBlockItemSyntax(item: .init(StmtSyntax("return \(raw: lowered)")))
+                return CodeBlockItemSyntax(item: .init(StmtSyntax("return \(raw: callExpr)")))
             }
 
             if returnType == .void {
@@ -394,18 +402,17 @@ public class ExportSwift {
                 return
             }
 
-            let returnAccessor = returnType.lowerAliases(expression: "ret")
             switch returnType {
             case .closure(_, useJSTypedClosure: false):
                 append("return JSTypedClosure(ret).bridgeJSLowerReturn()")
             case .array, .nullable(.array, _):
                 let stackCodegen = StackCodegen()
-                for stmt in stackCodegen.lowerStatements(for: returnType, accessor: returnAccessor, varPrefix: "ret") {
+                for stmt in stackCodegen.lowerStatements(for: returnType, accessor: "ret", varPrefix: "ret") {
                     append(stmt)
                 }
             case .dictionary(.swiftProtocol):
                 let stackCodegen = StackCodegen()
-                for stmt in stackCodegen.lowerStatements(for: returnType, accessor: returnAccessor, varPrefix: "ret") {
+                for stmt in stackCodegen.lowerStatements(for: returnType, accessor: "ret", varPrefix: "ret") {
                     append(stmt)
                 }
             case .swiftProtocol:
@@ -421,7 +428,7 @@ public class ExportSwift {
                     """
                 )
             default:
-                append("return \(raw: returnAccessor).bridgeJSLowerReturn()")
+                append("return ret.bridgeJSLowerReturn()")
             }
         }
 
@@ -880,7 +887,7 @@ struct StackCodegen {
         case .string, .integer, .bool, .float, .double,
             .jsObject(nil), .jsValue, .swiftStruct, .swiftHeapObject, .unsafePointer,
             .swiftProtocol, .caseEnum, .associatedValueEnum, .rawValueEnum, .array, .dictionary, .alias:
-            return "\(raw: type.liftAliases(expression: "\(type.unaliased.swiftType).bridgeJSStackPop()"))"
+            return "\(raw: type.swiftType).bridgeJSStackPop()"
         case .jsObject(let className?):
             return "\(raw: className)(unsafelyWrapping: JSObject.bridgeJSStackPop())"
         case .nullable(let wrappedType, let kind):
@@ -898,9 +905,7 @@ struct StackCodegen {
         case .string, .integer, .bool, .float, .double, .jsObject(nil), .jsValue,
             .swiftStruct, .swiftHeapObject, .caseEnum, .associatedValueEnum, .rawValueEnum,
             .array, .dictionary, .alias:
-            let popCall = "\(typeName)<\(wrappedType.unaliased.swiftType)>.bridgeJSStackPop()"
-            let nullableType = BridgeType.nullable(wrappedType, kind)
-            return "\(raw: nullableType.liftAliases(expression: popCall))"
+            return "\(raw: typeName)<\(raw: wrappedType.swiftType)>.bridgeJSStackPop()"
         case .jsObject(let className?):
             return "\(raw: typeName)<JSObject>.bridgeJSStackPop().map { \(raw: className)(unsafelyWrapping: $0) }"
         case .nullable, .void, .namespaceEnum, .closure, .unsafePointer, .swiftProtocol:
@@ -1208,10 +1213,9 @@ struct EnumCodegen {
     ) {
         for (index, associatedValue) in associatedValues.enumerated() {
             let paramName = associatedValue.label ?? "param\(index)"
-            let accessor = associatedValue.type.lowerAliases(expression: paramName)
             let statements = stackCodegen.lowerStatements(
                 for: associatedValue.type,
-                accessor: accessor,
+                accessor: paramName,
                 varPrefix: paramName
             )
             for statement in statements {
@@ -1344,10 +1348,9 @@ struct StructCodegen {
         let instanceProps = structDef.properties.filter { !$0.isStatic }
 
         for property in instanceProps {
-            let accessor = property.type.lowerAliases(expression: "self.\(property.name)")
             let statements = stackCodegen.lowerStatements(
                 for: property.type,
-                accessor: accessor,
+                accessor: "self.\(property.name)",
                 varPrefix: property.name
             )
             for statement in statements {
@@ -1359,6 +1362,18 @@ struct StructCodegen {
     }
 }
 
+// MARK: - AliasCodegen
+
+struct AliasCodegen {
+    func renderAliasConformance(_ alias: ExportedAlias) -> DeclSyntax? {
+        guard let protocols = alias.underlying.aliasConformanceProtocols else {
+            return nil
+        }
+        let conformances = (["_BridgedSwiftAlias"] + protocols).joined(separator: ", ")
+        return "extension \(raw: alias.swiftCallName): \(raw: conformances) {}"
+    }
+}
+
 // MARK: - ProtocolCodegen
 
 struct ProtocolCodegen {
@@ -1570,61 +1585,20 @@ extension UnsafePointerType {
 }
 
 extension BridgeType {
-    var unaliased: BridgeType {
-        switch self {
-        case .alias(_, let underlying): return underlying.unaliased
-        case .nullable(let wrapped, let kind): return .nullable(wrapped.unaliased, kind)
-        case .array(let element): return .array(element.unaliased)
-        case .dictionary(let value): return .dictionary(value.unaliased)
-        case .bool, .integer, .float, .double, .string, .jsValue, .jsObject,
-            .swiftHeapObject, .unsafePointer, .swiftProtocol, .void,
-            .caseEnum, .rawValueEnum, .associatedValueEnum, .swiftStruct,
-            .namespaceEnum, .closure:
-            return self
-        }
-    }
-
-    /// If this type contains an alias, convert the expression with a type of the alias to the underlying type.
-    func liftAliases(expression: String) -> String {
-        switch self {
-        case .alias(let name, _):
-            return "\(name).bridgeFromJS(\(expression))"
-        case .nullable(let wrapped, _):
-            let lifted = wrapped.liftAliases(expression: "$0")
-            return lifted == "$0" ? expression : "\(expression).map { \(lifted) }"
-        case .array(let element):
-            let lifted = element.liftAliases(expression: "$0")
-            return lifted == "$0" ? expression : "\(expression).map { \(lifted) }"
-        case .dictionary(let value):
-            let lifted = value.liftAliases(expression: "$0")
-            return lifted == "$0" ? expression : "\(expression).mapValues { \(lifted) }"
-        case .bool, .integer, .float, .double, .string, .jsValue, .jsObject,
-            .swiftHeapObject, .unsafePointer, .swiftProtocol, .void,
-            .caseEnum, .rawValueEnum, .associatedValueEnum, .swiftStruct,
-            .namespaceEnum, .closure:
-            return expression
-        }
-    }
-
-    /// Opposite of `liftAliases`: if this type contains an alias, convert the expression with a type of the underlying to the alias type.
-    func lowerAliases(expression: String) -> String {
+    var aliasConformanceProtocols: [String]? {
         switch self {
-        case .alias:
-            return "\(expression).bridgeToJS()"
-        case .nullable(let wrapped, _):
-            let lowered = wrapped.lowerAliases(expression: "$0")
-            return lowered == "$0" ? expression : "\(expression).map { \(lowered) }"
-        case .array(let element):
-            let lowered = element.lowerAliases(expression: "$0")
-            return lowered == "$0" ? expression : "\(expression).map { \(lowered) }"
-        case .dictionary(let value):
-            let lowered = value.lowerAliases(expression: "$0")
-            return lowered == "$0" ? expression : "\(expression).mapValues { \(lowered) }"
-        case .bool, .integer, .float, .double, .string, .jsValue, .jsObject,
-            .swiftHeapObject, .unsafePointer, .swiftProtocol, .void,
-            .caseEnum, .rawValueEnum, .associatedValueEnum, .swiftStruct,
-            .namespaceEnum, .closure:
-            return expression
+        case .swiftHeapObject, .jsObject, .integer, .float, .double, .bool, .string, .jsValue:
+            return ["_BridgedSwiftStackType"]
+        case .swiftStruct:
+            return ["_BridgedSwiftStruct"]
+        case .caseEnum:
+            return ["_BridgedSwiftCaseEnum"]
+        case .associatedValueEnum:
+            return ["_BridgedSwiftAssociatedValueEnum"]
+        case .rawValueEnum, .void, .unsafePointer, .namespaceEnum,
+            .swiftProtocol, .closure, .nullable, .array, .dictionary, .alias:
+            // Not supported yet.
+            return nil
         }
     }
 

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -172,8 +172,7 @@ public struct ImportTS {
             if loweringInfo.useBorrowing {
                 let returnVariableName = "ret\(borrowedArguments.count)"
                 let assign = needsReturnVariable ? "let \(returnVariableName) = " : ""
-                let loweredAlias = param.type.lowerAliases(expression: param.name)
-                body.write("\(assign)\(loweredAlias).bridgeJSWithLoweredParameter { \(pattern) in")
+                body.write("\(assign)\(param.name).bridgeJSWithLoweredParameter { \(pattern) in")
                 body.indent()
                 borrowedArguments.append(
                     BorrowedArgument(
@@ -204,8 +203,7 @@ public struct ImportTS {
                         "(\(raw: param.name) as! _BridgedSwiftProtocolExportable).bridgeJSLowerAsProtocolReturn()"
                     )
                 } else {
-                    let loweredAlias = param.type.lowerAliases(expression: param.name)
-                    initializerExpr = ExprSyntax("\(raw: loweredAlias).bridgeJSLowerParameter()")
+                    initializerExpr = ExprSyntax("\(raw: param.name).bridgeJSLowerParameter()")
                 }
 
                 if loweringInfo.loweredParameters.isEmpty {
@@ -296,21 +294,18 @@ public struct ImportTS {
 
             if returnType.usesSideChannelForOptionalReturn() {
                 // Side channel returns: extern function returns Void, value is retrieved via side channel
-                let liftCall = "\(returnType.unaliased.swiftType).bridgeJSLiftReturnFromSideChannel()"
-                body.write("return \(returnType.liftAliases(expression: liftCall))")
+                body.write("return \(returnType.swiftType).bridgeJSLiftReturnFromSideChannel()")
             } else {
                 let liftExpr: String
                 switch returnType {
                 case .closure(let signature, _):
                     liftExpr = "_BJS_Closure_\(signature.mangleName).bridgeJSLift(ret)"
                 default:
-                    let liftCall: String
                     if liftingInfo.valueToLift != nil {
-                        liftCall = "\(returnType.unaliased.swiftType).bridgeJSLiftReturn(ret)"
+                        liftExpr = "\(returnType.swiftType).bridgeJSLiftReturn(ret)"
                     } else {
-                        liftCall = "\(returnType.unaliased.swiftType).bridgeJSLiftReturn()"
+                        liftExpr = "\(returnType.swiftType).bridgeJSLiftReturn()"
                     }
-                    liftExpr = returnType.liftAliases(expression: liftCall)
                 }
                 body.write("return \(liftExpr)")
             }
@@ -908,7 +903,7 @@ extension BridgeType {
     }
 
     func loweringParameterInfo(context: BridgeContext = .importTS) throws -> LoweringParameterInfo {
-        switch self {
+        switch self.unaliased {
         case .bool: return .bool
         case .integer(let t): return LoweringParameterInfo(loweredParameters: [("value", t.wasmCoreType)])
         case .float: return .float
@@ -962,8 +957,8 @@ extension BridgeType {
             return LoweringParameterInfo(loweredParameters: params, useBorrowing: wrappedInfo.useBorrowing)
         case .array, .dictionary:
             return LoweringParameterInfo(loweredParameters: [])
-        case .alias(_, let underlying):
-            return try underlying.loweringParameterInfo(context: context)
+        case .alias:
+            preconditionFailure()
         }
     }
 
@@ -983,7 +978,7 @@ extension BridgeType {
     func liftingReturnInfo(
         context: BridgeContext = .importTS
     ) throws -> LiftingReturnInfo {
-        switch self {
+        switch self.unaliased {
         case .bool: return .bool
         case .integer(let t): return LiftingReturnInfo(valueToLift: t.wasmCoreType)
         case .float: return .float
@@ -1026,7 +1021,7 @@ extension BridgeType {
         case .nullable(let wrappedType, _):
             // jsObject and `@JS struct` use the stack ABI for optionals — the thunk returns
             // void and the value (plus isSome discriminator) flows through the stacks.
-            if case .jsObject = wrappedType.unaliased {
+            if case .jsObject = wrappedType {
                 return LiftingReturnInfo(valueToLift: nil)
             }
             if case .swiftStruct = wrappedType, context == .importTS {
@@ -1036,8 +1031,8 @@ extension BridgeType {
             return LiftingReturnInfo(valueToLift: wrappedInfo.valueToLift)
         case .array, .dictionary:
             return LiftingReturnInfo(valueToLift: nil)
-        case .alias(_, let underlying):
-            return try underlying.liftingReturnInfo(context: context)
+        case .alias:
+            preconditionFailure()
         }
     }
 }

Plugins/BridgeJS/Sources/BridgeJSCore/SwiftToSkeleton.swift

@@ -552,10 +552,7 @@ public final class SwiftToSkeleton {
         swiftCallName: String,
         errors: inout [DiagnosticError]
     ) -> BridgeType? {
-        if let targetDecl = typeDeclResolver.resolve(aliasTarget),
-            let targetJSAttribute = targetDecl.attributes.firstJSAttribute,
-            extractAliasTarget(from: targetJSAttribute) != nil
-        {
+        func diagnoseChainedAlias() -> BridgeType? {
             errors.append(
                 DiagnosticError(
                     node: aliasTarget,
@@ -565,7 +562,17 @@ public final class SwiftToSkeleton {
             )
             return nil
         }
+        if let targetDecl = typeDeclResolver.resolve(aliasTarget),
+            let targetJSAttribute = targetDecl.attributes.firstJSAttribute,
+            extractAliasTarget(from: targetJSAttribute) != nil
+        {
+            return diagnoseChainedAlias()
+        }
         guard let targetType = lookupType(for: aliasTarget, errors: &errors) else { return nil }
+        if case .alias = targetType {
+            // Alias declared in another module.
+            return diagnoseChainedAlias()
+        }
         if case .swiftProtocol = targetType {
             errors.append(
                 DiagnosticError(
@@ -1697,6 +1704,15 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             errors.append(contentsOf: lookupErrors)
             return
         }
+        guard underlying.aliasConformanceProtocols != nil else {
+            errors.append(
+                DiagnosticError(
+                    node: aliasTarget,
+                    message: "Representation \(underlying.swiftType) is not supported"
+                )
+            )
+            return
+        }
         exportedAliases.append(
             ExportedAlias(swiftCallName: swiftCallName, underlying: underlying)
         )