Start work on ability to load wasm languages from native lib, via wasmtime

lib/binding_rust/bindings.rs

@@ -853,6 +853,51 @@ extern "C" {
     #[doc = " See also `ts_parser_set_language`."]
     pub fn ts_language_version(arg1: *const TSLanguage) -> u32;
 }
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct wasm_engine_t {
+    _unused: [u8; 0],
+}
+pub type TSWasmEngine = wasm_engine_t;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TSWasmStore {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TSWasmLanguage {
+    _unused: [u8; 0],
+}
+extern "C" {
+    pub fn ts_wasm_store_new(engine: *mut TSWasmEngine) -> *mut TSWasmStore;
+}
+extern "C" {
+    pub fn ts_wasm_store_delete(arg1: *mut TSWasmStore);
+}
+extern "C" {
+    pub fn ts_wasm_language_delete(arg1: *const TSWasmLanguage);
+}
+extern "C" {
+    pub fn ts_wasm_store_load_language(
+        arg1: *mut TSWasmStore,
+        name: *const ::std::os::raw::c_char,
+        wasm: *const ::std::os::raw::c_char,
+        wasm_len: u32,
+    ) -> *mut TSWasmLanguage;
+}
+extern "C" {
+    pub fn ts_wasm_store_add_language(arg1: *mut TSWasmStore, arg2: *const TSWasmLanguage);
+}
+extern "C" {
+    pub fn ts_parser_set_wasm_language(arg1: *mut TSParser, arg2: *const TSWasmLanguage);
+}
+extern "C" {
+    pub fn ts_parser_wasm_language(arg1: *mut TSParser) -> *const TSWasmLanguage;
+}
+extern "C" {
+    pub fn ts_parser_set_wasm_store(arg1: *mut TSParser, arg2: *mut TSWasmStore);
+}
 extern "C" {
     #[doc = " Set the allocation functions used by the library."]
     #[doc = ""]

lib/binding_rust/build.rs

@@ -17,6 +17,13 @@ fn main() {
         }
     }
 
+    let mut config = cc::Build::new();
+
+    println!("cargo:rerun-if-env-changed=CARGO_FEATURE_WASM");
+    if env::var("CARGO_FEATURE_WASM").is_ok() {
+        config.define("TREE_SITTER_FEATURE_WASM", "");
+    }
+
     let src_path = Path::new("src");
     for entry in fs::read_dir(&src_path).unwrap() {
         let entry = entry.unwrap();
@@ -24,7 +31,7 @@ fn main() {
         println!("cargo:rerun-if-changed={}", path.to_str().unwrap());
     }
 
-    cc::Build::new()
+    config
         .flag_if_supported("-std=c99")
         .flag_if_supported("-Wno-unused-parameter")
         .include(src_path)

lib/binding_rust/lib.rs

@@ -18,6 +18,11 @@ use std::{
     u16,
 };
 
+#[cfg(feature = "wasm")]
+mod wasm_language;
+#[cfg(feature = "wasm")]
+pub use wasm_language::*;
+
 /// The latest ABI version that is supported by the current version of the
 /// library.
 ///

lib/binding_rust/wasm_language.rs

@@ -0,0 +1,76 @@
+use crate::{LanguageError, Parser};
+
+use super::ffi;
+use std::{ffi::CString, os::raw::c_char};
+pub use wasmtime;
+
+#[cfg(feature = "wasm")]
+pub fn test() {
+    wasmtime_c_api::wasm_engine_new();
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_engine_t {
+    pub(crate) engine: wasmtime::Engine,
+}
+
+pub struct WasmStore(*mut ffi::TSWasmStore);
+pub struct WasmLanguage(*const ffi::TSWasmLanguage);
+
+impl WasmStore {
+    pub fn new(engine: wasmtime::Engine) -> Self {
+        let mut c_engine = wasm_engine_t { engine };
+        let c_engine = &mut c_engine as *mut _;
+        WasmStore(unsafe { ffi::ts_wasm_store_new(c_engine as *mut _) })
+    }
+
+    pub fn load_language(&mut self, name: &str, bytes: &[u8]) -> WasmLanguage {
+        let name = CString::new(name).unwrap();
+        WasmLanguage(unsafe {
+            ffi::ts_wasm_store_load_language(
+                self.0,
+                name.as_ptr(),
+                bytes.as_ptr() as *const c_char,
+                bytes.len() as u32,
+            )
+        })
+    }
+}
+
+impl Parser {
+    pub fn wasm_language(&self) -> Option<WasmLanguage> {
+        let language = unsafe { ffi::ts_parser_wasm_language(self.0.as_ptr()) };
+        if language.is_null() {
+            None
+        } else {
+            Some(WasmLanguage(language))
+        }
+    }
+
+    pub fn set_wasm_language(&mut self, language: WasmLanguage) -> Result<(), LanguageError> {
+        unsafe {
+            ffi::ts_parser_set_wasm_language(self.0.as_ptr(), language.0);
+        }
+        Ok(())
+    }
+
+    pub fn set_wasm_store(&mut self, language: WasmStore) -> Result<(), LanguageError> {
+        unsafe {
+            ffi::ts_parser_set_wasm_store(self.0.as_ptr(), language.0);
+        }
+        Ok(())
+    }
+}
+
+impl Drop for WasmLanguage {
+    fn drop(&mut self) {
+        unsafe { ffi::ts_wasm_language_delete(self.0) };
+    }
+}
+
+impl Drop for WasmStore {
+    fn drop(&mut self) {
+        unsafe { ffi::ts_wasm_store_delete(self.0) };
+    }
+}