Add RustVec<T>.as_ptr method

[aiongg]

This PR adds a method to the Vectorizable protocol:

static func vecOfSelfAsPtr(vecPtr: UnsafeMutableRawPointer) -> UnsafePointer<SelfRef>

My reason for adding this method was to be able to easily pass a serialized Protobuf object back and forth between Rust and Swift. Motivating example:

// rust

// Receives a serialized protobuf message and returns a serialized protobuf message
fn send_serialized_proto(bytes: &[u8]) -> Option<Vec<u8>> {
    // ...
}

Without .as_ptr(), it was necessary to return the raw pointer from Rust, which meant also returning the length separately, so using the Rust method was a bit less ergonomic on both sides. Here's how it looks now:

// swift

let message = My_Proto_Message()
// ...
guard let input = message.serializedData() else { ... }

guard let output: RustVec<UInt8>? = data.withUnsafeBytes {
    (ptr: UnsafeRawBufferPointer) -> RustVec<UInt8>? in
    let u8ptr = ptr.bindMemory(to: UInt8.self)
    return send_serialized_proto(u8ptr)
} else { ... }

do {
    let response = try My_Proto_Response.init(
        serializedData: Data(
            // The `.as_ptr()` method keeps this very straightforward
            bytes: output.as_ptr(),
            count: output.len()
        )
    )
} catch { ... }

// ...

[aiongg]

Basic test as described in the issue.

[aiongg]

Add the new typealias up top, and add the method implementation below (I put it after the get methods) - it's the same procedure for all of these generated code segments.

[aiongg]

We just leave the type parameter as Elem in line with the Vectorizable protocol, and all we have to do is change the method name to call the appropriate $Vec_{rust_ty}$as_ptr function.

[aiongg]

Special handling for RustString, which takes a UInt8 type parameter instead of the usual Self.

[aiongg]

Implementation for RustString. This is the *const u8 that maps to UnsafePointer<UInt8> in swift.

[aiongg]

The new associatedtype Elem for the Vectorizable protocol

[chinedufn]

Thanks for submitting! Will review tonight or tomorrow

[chinedufn]

.as_ptr() for a RustVec<RustString> should not return an UnsafePointer<UInt8>, but rather an UnsafePointer<RustStringRef>.

Consider the following Rust code:

let strings: Vec<String> = vec![];
let ptr: *const String = strings.as_ptr();

Vec<String>.as_ptr() returns a *const String.

Maybe you were accidentally looking at String.as_ptr(), which is unrelated to this PR.

---

So, I think we can remove the Elem associated type and instead just have the existing SelfRef associated type

swift-bridge/crates/swift-bridge-build/src/generate_core/rust_vec.swift

Line 95 in 53ab502

associatedtype SelfRef

, which from RustVec<RustString> is a RustStringRef

swift-bridge/crates/swift-bridge-build/src/generate_core/rust_string.swift

Line 72 in 53ab502

public static func vecOfSelfGet(vecPtr: UnsafeMutableRawPointer, index: UInt) -> Optional<RustStringRef> {

[aiongg]

Ok great I'll try it. I think I tried that the first time and encountered some issue, but if you think it should work then I must have done something wrong so I'll try again and update the PR if it works.

[chinedufn]

Mmm I'm not certain that it'll work exactly as I described it but it seems directionally correct. Let me know if you run into an issue.

[aiongg]

@chinedufn you were right, I was confusing RustString with RustVec<RustString>. Works fine with SelfRef as you described. Makes more sense now, too. I guess that's what I get for trying to do it at 2am last time 😅

[chinedufn]

Thanks looks good.

All that's missing is to update your PR body with quick example code showing of what this PR now enables.

Here's an example from another PR that you can use as inspiration #189

These examples get used in our release notes, and they help folks that are looking at old PRs understand exactly what the PR does.

Once you add an example (and perhaps clean up the info in your PR body that is no longer true) we can merge this!

[aiongg]

@chinedufn done, please review.

[chinedufn]

Thanks!

FYI for PRs you can just show bridge module and an example of using that module like this:

// Rust

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        fn send_serialized_proto(bytes: &[u8]) -> Option<Vec<u8>>;
    }
}

// Swift

// ... then you could've put your example of using it here ...