Rust の他言語バインディング生成ライブラリ UniFFI を試す

[lib]
crate-type = ["cdylib"]

fn add(a: u32, b: u32) -> u32 {
    a + b
}

namespace math {
  u32 add(u32 a, u32 b);
};

[dependencies]
uniffi = "0.21.0"
uniffi_macros = "0.21.0"

[build-dependencies]
uniffi_build = "0.21.0"

fn main() {
    uniffi_build::generate_scaffolding("./src/lib.udl").unwrap();
}

use uniffi_macros;

uniffi_macros::include_scaffolding!("lib");

cargo install uniffi_bindgen

[build-dependencies]
uniffi_build = {version = "0.21.0", features = [ "builtin-bindgen" ]}

use camino::Utf8Path;
use std::env;
use std::path::Path;

fn main() {
    let out_dir = env::var_os("OUT_DIR").unwrap();

    uniffi_build::generate_scaffolding("./src/lib.udl").unwrap();
    uniffi_bindgen::generate_bindings(
        Utf8Path::new("./src/lib.udl"),
        None,
        vec!["swift"],
        Utf8Path::from_path(Path::new(&out_dir)),
        None,
        false,
    )
    .unwrap();
}

$ cargo build --message-format=json | jq .
...
{
  "reason": "build-script-executed",
  "package_id": "tokenizers-ffi 0.1.0 (path+file:///Users/takanori.ishikawa/Developer/Workspace/tokenizers-swift/ffi)",
  "linked_libs": [],
  "linked_paths": [],
  "cfgs": [],
  "env": [],
  "out_dir": "/Users/takanori.ishikawa/Developer/Workspace/tokenizers-swift/ffi/target/debug/build/tokenizers-ffi-684fc4c089349484/out"
}

mkdir -p .build
cp -r ./target/debug/build/tokenizers-ffi-684fc4c089349484/out/*.{h,swift,modulemap} .build/

$ swiftc -parse-as-library \
	-emit-module -emit-module-path .build -module-name math -module-link-name math \
	-emit-library -o .build/libmath.dylib \
  -L ./target/debug -ltokenizers_ffi \
  -I .build \
  -Xcc -fmodule-map-file=.build/mathFFI.modulemap \
  .build/math.swift

$ tree build       
build
├── libmath.dylib
└── math.swiftmodule

$ swift repl -I./build -L./build -Xcc -fmodule-map-file=.build/mathFFI.modulemap
Welcome to Apple Swift version 5.7 (swiftlang-5.7.0.127.4 clang-1400.0.29.50).
Type :help for assistance.
  1> import math
  2> math.add(a: 10, b: 20)
$R0: UInt32 = 30

$ cargo metadata --no-deps --format-version 1 | jq ".packages[0].name"
"tokenizers-ffi"

$ cargo check --message-format json | jq -r 'if .reason == "build-script-executed" and (.package_id | contains("tokenizers")) then .out_dir else empty end'

interface Tokenizer {
  static Tokenizer from_pretrained([ByRef] string identifier);
};

  Caused by:
      method modifiers are not supported', build.rs:8:57

interface Tokenizer {
  [Name=from_pretrained]
  constructor([ByRef] string identifier);
};

2> Tokenizer.fromPretrained(identifier: "bert-base-cased") 
$R0: tokenizers.Tokenizer = {
  pointer = 0x600000004040
}

pub struct Tokenizer {}

impl Tokenizer {
    pub fn from_pretrained(identifier: &str, revision: String, auth_token: Option<String>) -> Self {
        Self {}
    }
}

interface Tokenizer {
  [Name=from_pretrained]
  constructor(
    [ByRef] string identifier,
    optional string revision = "main",
    optional string? auth_token = null);
};

Tokenizer.fromPretrained(identifier: "bert-base-cased", revision: "main2")
Tokenizer.fromPretrained(identifier: "bert-base-cased", revision: "main2", authToken: "hasdkfk")

use std::sync::Arc;
use tokenizers as tk;

pub struct Tokenizer {
    tokenizer: Arc<tk::tokenizer::Tokenizer>,
}

impl Tokenizer {
    pub fn from_pretrained(identifier: &str, revision: String, auth_token: Option<String>) -> Self {
        let params = tk::FromPretrainedParameters {
            revision,
            auth_token,
            user_agent: [("bindings", "Swift"), ("version", crate::VERSION)]
                .iter()
                .map(|(k, v)| (k.to_string(), v.to_string()))
                .collect(),
        };
        let tokenizer =
            tk::tokenizer::Tokenizer::from_pretrained(identifier, Some(params)).unwrap();

        Self {
            tokenizer: Arc::new(tokenizer),
        }
    }
}

  1> import tokenizers
  2> let tokenizer = Tokenizer.fromPretrained(identifier: "bert-base-cased")
Downloaded 425.58KiB in 0s
tokenizer: tokenizers.Tokenizer = {
  pointer = 0x600000202790
}

.
├── Package.swift
├── Sources
│   ├── Tokenizers
│   │   └── Tokenizers.swift
│   └── TokenizersFFI
│       ├── TokenizersFFI.c
│       └── include
│           └── TokenizersFFI.h

// swift-tools-version: 5.7
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "Tokenizers",
    products: [
        .library(
            name: "Tokenizers",
            targets: ["Tokenizers"])
    ],
    dependencies: [],
    targets: [
        .target(
            name: "Tokenizers",
            dependencies: ["TokenizersFFI"],
            linkerSettings: [
                .linkedLibrary("tokenizers")
            ]),
        .target(
            name: "TokenizersFFI",
            dependencies: []),
        .testTarget(
            name: "TokenizersTests",
            dependencies: ["Tokenizers"]),
    ]
)

$ swift run -Xlinker -L../../target/debug  
Building for debugging...
ld: warning: dylib (../../target/debug/libtokenizers.dylib) was built for newer macOS version (12.0) than being linked (11.0)
[1/1] Linking Example
Build complete! (0.19s)

$ swift run --repl -Xlinker="-Ltarget/debug"

[ByRef] string?

([ByRef] string)?