How to produce a .wasm binary?

[duarten]

Using a shared library doesn't seem to work.

rust_shared_library(
    name = "foo",
    srcs = glob(["src/*.rs"]),
    aliases = aliases(),
    compile_data = ["Cargo.toml"],
    proc_macro_deps = all_crate_deps(proc_macro = True),
    deps = all_crate_deps(normal = True),
    platform = "@rules_rust//rust/platform:wasm",
)

results in

Error in create_library_to_link: 'cleanup.wasm' does not have any of the allowed extensions .so, .dylib, .dll or .pyd

Using a rust_binary with the out_binary and crate_type option also does not work.

rust_binary(
    name = "cleanup",
    srcs = glob(["src/*.rs"]),
    aliases = aliases(),
    compile_data = ["Cargo.toml"],
    proc_macro_deps = all_crate_deps(proc_macro = True),
    deps = all_crate_deps(normal = True),
    platform = "@rules_rust//rust/platform:wasm",
    out_binary = True,
    crate_type = "cdylib",
)

results in

external/rules_rust/rust/private/rust.bzl:211:5: rule advertised the 'CrateInfo' provider, but this provider was not among those returned

[akesling]

Apologies if this isn't quite the direction you want to go in, but while I don't have experience using rust_shared_library specifically, I do have experience getting Rust Wasm binaries + libraries to build under Bazel. The key is to realize that you need to convince Bazel to apply a platform transition to the build graph. Please take a moment to read the Bazel configuration transition docs for context on what on earth is actually happening here.

I've built a few helpers that make this easier for my project. The core of all of this is a wasm "platform transition":

def _wasm_rust_transition_impl(settings, attr):
    return {
        "//command_line_option:platforms": "@rules_rust//rust/platform:wasm",
    }

wasm_rust_transition = transition(
    implementation = _wasm_rust_transition_impl,
    inputs = [],
    outputs = [
        "//command_line_option:platforms",
    ],
)

I apply this transition to a cheeky little helper that "just" copies the final rust binary file for me... but keep in mind that this little transition at the final step in the build graph makes everything work! I believe I learned this trick via the Envoy Rust Bazel Wasm rules... but TBH, I can't quite remember.

def _wasm_binary_impl(ctx):
    out = ctx.actions.declare_file(ctx.label.name)
    ctx.actions.run(
        executable = "cp",
        arguments = [ctx.files.binary[0].path, out.path],
        outputs = [out],
        inputs = ctx.files.binary,
    )

    return [
        DefaultInfo(
            files = depset([out]),
            runfiles = ctx.runfiles([out]))]

def _wasm_attrs(transition):
    return {
        "binary": attr.label(mandatory = True, cfg = transition),
        "_whitelist_function_transition": attr.label(
            default = "@bazel_tools//tools/whitelists/function_transition_whitelist"),
    }

wasm_rust_binary_rule = rule(
    implementation = _wasm_binary_impl,
    attrs = _wasm_attrs(wasm_rust_transition),
)

And to make everything ergonomic, I provide a macro that forwards everything I need to a rust_binary and wraps it in the copier/transition-applier.

def wasm_rust_binary(name, **kwargs):
    wasm_name = "_wasm_" + name.replace(".", "_")
    # Remove double-underscores to enforce snake case in case, for example,
    # `name` was underscore prefixed.
    wasm_name = wasm_name.replace("__", "_")
    kwargs.setdefault("visibility", ["//visibility:public"])

    rust_binary(
        name = wasm_name,
        crate_type = "cdylib",
        out_binary = True,
        target_compatible_with = select({
            "//bazel/config:platform_is_rust_wasm": [],
            "//conditions:default": ["@platforms//:incompatible"],
        }),
        **kwargs
    )

    wasm_rust_binary_rule(
        name = name,
        binary = ":" + wasm_name,
    )

Then I can include any of my Rust libraries as normal rust_librarys included via deps for a wasm_rust_binary and the transition will apply through the whole build graph.

P.S. Note that there's a special little config value in that rust_binary select which forces these binaries to fail when forced into a build graph not configured for the wasm platform. Here's all that is:

config_setting(
    name = "platform_is_rust_wasm",
    values = {"platforms": "@rules_rust//rust/platform:wasm"},
)

[akesling]

After spending the time to write this up, I decided to see if someone had any answers over on Stackoverflow. I couldn't find one, so I posted this Q/A over there as well: https://stackoverflow.com/questions/78168400/how-do-you-build-a-rust-wasm-binary-with-bazel/78168401#78168401. Let me know if helps and if there's anything I can clarify!

[bcmyers]

For anyone else who comes along and wants to use this...

I got stuck for a few minutes on the fact that name must end in .wasm.

I added somethign like this to make it clearer to users.

def wasm_rust_binary(name, **kwargs):
    if not name.endswith(".wasm"):
        fail("name must end with .wasm")
    ...

It also appears to require patching rules_rust with this: #1315

But otherwise, super helpful. Thank you!

[akesling]

Ah yes, I forgot I had #1315 patched in as well. Good catch!

[duarten]

Thanks! What I ended up doing was:

rust_binary(
    name = "name",
    srcs = glob(["src/*.rs"]),
    aliases = aliases(),
    compile_data = ["Cargo.toml"],
    proc_macro_deps = all_crate_deps(proc_macro = True),
    deps = all_crate_deps(normal = True),
    platform = "@rules_rust//rust/platform:wasm",
    out_binary = True,
    crate_type = "cdylib",
)

And applying the following patch to rules_rust: #1315