Restucture wasm module, return a normal TSLanguage from load_language

lib/binding_rust/bindings.rs

@@ -864,40 +864,29 @@ pub type TSWasmEngine = wasm_engine_t;
 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;
+    ) -> *const TSLanguage;
 }
 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;
+    pub fn ts_language_is_wasm(arg1: *const TSLanguage) -> bool;
 }
 extern "C" {
     pub fn ts_parser_set_wasm_store(arg1: *mut TSParser, arg2: *mut TSWasmStore);
 }
+extern "C" {
+    pub fn ts_parser_wasm_store(arg1: *mut TSParser) -> *mut TSWasmStore;
+}
 extern "C" {
     #[doc = " Set the allocation functions used by the library."]
     #[doc = ""]

lib/binding_rust/build.rs

@@ -35,6 +35,7 @@ fn main() {
         .flag_if_supported("-std=c99")
         .flag_if_supported("-Wno-unused-parameter")
         .include(src_path)
+        .include(src_path.join("wasm"))
         .include("include")
         .file(src_path.join("lib.c"))
         .compile("tree-sitter");

lib/binding_rust/wasm_language.rs

@@ -1,7 +1,5 @@
-use crate::{LanguageError, Parser};
-
-use super::ffi;
-use std::{ffi::CString, os::raw::c_char};
+use crate::{ffi, Language, LanguageError, Parser};
+use std::{ffi::CString, mem, os::raw::c_char};
 pub use wasmtime;
 
 #[cfg(feature = "wasm")]
@@ -16,18 +14,22 @@ pub struct wasm_engine_t {
 }
 
 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 _) })
+        let mut c_engine = Box::new(wasm_engine_t {
+            engine: engine.clone(),
+        });
+        let result = WasmStore(unsafe {
+            ffi::ts_wasm_store_new(c_engine.as_mut() as *mut wasm_engine_t as *mut _)
+        });
+        mem::forget(c_engine);
+        result
     }
 
-    pub fn load_language(&mut self, name: &str, bytes: &[u8]) -> WasmLanguage {
+    pub fn load_language(&mut self, name: &str, bytes: &[u8]) -> Language {
         let name = CString::new(name).unwrap();
-        WasmLanguage(unsafe {
+        Language(unsafe {
             ffi::ts_wasm_store_load_language(
                 self.0,
                 name.as_ptr(),
@@ -38,34 +40,19 @@ impl WasmStore {
     }
 }
 
-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 Language {
+    pub fn is_wasm(&self) -> bool {
+        unsafe { ffi::ts_language_is_wasm(self.0) }
     }
 }
 
-impl Drop for WasmLanguage {
-    fn drop(&mut self) {
-        unsafe { ffi::ts_wasm_language_delete(self.0) };
+impl Parser {
+    pub fn set_wasm_store(&mut self, store: WasmStore) -> Result<(), LanguageError> {
+        unsafe {
+            ffi::ts_parser_set_wasm_store(self.0.as_ptr(), store.0);
+        }
+        mem::forget(store);
+        Ok(())
     }
 }