bindgen | generates bindings and idiomatic Go interfaces | Parser library

Short answer: just cast it to *mut T and pass it to C.

Long answer:

It's best to first understand why casting *const T to *mut T is prone to undefined behaviour.

Rust's memory model ensures that a &mut T will not alias with anything else, so the compiler is free to, say, clobber T entirely and then restore its content, and the programmer could not observe that behaviour. If a &mut T and &T co-exists and point to the same location, undefined behaviour arises because what will happen if you read from &T while compiler clobbers &mut T? Similarly, if you have &T, the compiler assumes no one will modify it (excluding interior mutability through UnsafeCell), and undefined behaviour arise if the memory it points to is modified.

With the background, it's easy to see why *const T to *mut T is dangerous -- you cannot dereference the resulting pointer. If you ever dereference the *mut T, you've obtained a &mut T, and it'll be UB. However, the casting operation itself is safe, and you can safely cast the *mut T back to *const T and dereference it.

This is Rust semantics; on the C-side, the guarantee about T* is very weak. If you hold a T*, the compiler cannot assume there are no sharers. In fact, the compiler cannot even assert that it points to valid address (it could be null or past-the-end pointer). C compiler cannot generate store instructions to the memory location unless the code write to the pointer explicitly.

The weaker meaning of T* in C-side means that it won't violate Rust's assumption about semantics of &T. You can safely cast &T to *mut T and pass it to C, provided that C-side never modifies the memory pointed by the pointer.

Note that you can instruct the C compiler that the pointer won't alias with anything else with T * restrict, but as the C code you mentioned is not strict with const-correctness, it probably does not use restrict as well.

The workaround is to wrap the parserange::Error in a tuple struct to create a new type. The downside of this is that all functions defined on parserange::Error that you'd like to use will have to be redefined to call the error sub-object's function. This has all the advantages of creating a new type though, such as exporting in through wasm_bindgen, or implementing traits on a type defined in another crate. More information can be found here

Yes, this is possible.

WebAssembly stores objects within linear memory, a contiguous array of bytes that the module can read and write to. The host environment (typically JavaScript within the web browser) can also read and write to linear memory, allowing it to access the objects that the WebAssembly modules stores there.

There are two challenges here:

1. How do you find where your WebAssembly module has stored an object?
2. How is the object encoded?

You need to ensure that you can read and write these objects from both the WebAssembly module and the JavaScript host.

I'd pick a known memory location, and a known serialisation format and use that to read/write from both sides.

All you need to be able to reexport a function definition is for it to be (1) visible to the reexporting module and (2) marked pub. In particular, its containing module does not need to be marked pub. That means you can do this:

I was able to get it working by loading my application in the following way.

My webpack entry config looks like this:

Use <*const T>::as_ref¹:

This construction:

It won't work as easily as you'd expect: WASM bytecode is executed in a protected environment without any access to OS features like disk, network, conventional random generators and any other type of I/O. Consequently, the moment you compile any Rust code using such features into Wasm, it won't work.

Unfortunately your code (e.g. file access) usually even compiles silently and then fails in mysterious ways during runtime. This is not what you got used to using Rust and a major drawback of the current Wasm Rust stack.

To access OS features, you'll need WASI (Wasm System Interface) as an extension. To enable Wasi in NodeJs, you can use something like WasmerJs, see e.g. this article providing a short summary to do so.

The ultimate solution turned out to be that Rust's #[link(name="libname", kind="dylib")] annotation functions like the __declspec(dllimport) annotation in C++. I added some code to my build script to automatically insert this annotation above every part where bindgen created bindings for a global variable: