rome · ematipico · Feb 15, 2023 · Dec 30, 2022 · Dec 30, 2022 · Dec 30, 2022
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -1,5 +1,5 @@
 [alias]
-lint = "clippy --workspace --all-targets --verbose -- --deny warnings -W clippy::cargo -W clippy::dbg_macro -A clippy::cargo_common_metadata"
+lint = "clippy --workspace --all-targets --verbose -- --deny warnings -W clippy::cargo -W clippy::dbg_macro -A clippy::cargo_common_metadata -A clippy::multiple_crate_versions"
 format = "fmt --all --verbose"
 codegen = "run -p xtask_codegen --"
 codegen-configuration = "run -p xtask_codegen --features configuration -- configuration"

diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
@@ -49,7 +49,7 @@ jobs:
         uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --all-targets --all-features --verbose -- --deny warnings -W clippy::cargo -W clippy::dbg_macro -A clippy::cargo_common_metadata
+          args: --workspace --all-targets --all-features --verbose -- --deny warnings -W clippy::cargo -W clippy::dbg_macro -A clippy::cargo_common_metadata -A clippy::multiple_crate_versions
       - name: Run cargo check
         uses: actions-rs/cargo@v1
         with:

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -88,7 +88,7 @@ The npm module npm/rome contains Rome's Node JS API that supports different back
 For testing and developing, you need to build these packages, following the steps:
 1. install [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) globally;
 2. run the `build` command inside the package `backend-jsonrpc`;
-3. run the `build:wasm-node-dev` command inside the package `js-api` (folder `npm/js-api`);
+3. run the `build` and `build:wasm-node-dev` commands inside the package `js-api` (folder `npm/js-api`);
 4. run `pnpm i` inside the package `js-api` (folder `npm/js-api`), this will link the WebAssembly bindings and the
 JSON-RPC bindings;
 

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/rome_js_analyze/Cargo.toml b/crates/rome_js_analyze/Cargo.toml
@@ -19,7 +19,7 @@ rome_console = { path = "../rome_console" }
 rome_diagnostics = { path = "../rome_diagnostics" }
 rome_deserialize = { path = "../rome_deserialize" }
 rome_aria = { path = "../rome_aria" }
-roaring = "0.9.0"
+roaring = "0.10.1"
 rustc-hash = { workspace = true }
 serde = { version = "1.0.136", features = ["derive"] }
 serde_json = { version = "1.0.74", features = ["raw_value"] }

diff --git a/crates/rome_rowan/Cargo.toml b/crates/rome_rowan/Cargo.toml
@@ -13,7 +13,7 @@ hashbrown = { version = "0.12.3", features = [
     "inline-more",
 ], default-features = false }
 rome_text_size = { path = "../rome_text_size"}
-memoffset = "0.6.5"
+memoffset = "0.8.0"
 countme = { workspace = true }
 serde = { version = "1.0.133", optional = true, default-features = false }
 rome_text_edit = { path = "../rome_text_edit" }

diff --git a/crates/rome_wasm/Cargo.toml b/crates/rome_wasm/Cargo.toml
@@ -16,6 +16,8 @@ default = ["console_error_panic_hook"]
 
 [dependencies]
 wasm-bindgen = { version = "0.2.82", features = ["serde-serialize"] }
+serde = "1.0.136"
+serde-wasm-bindgen = "0.4.5"
 js-sys = "0.3.59"
 rome_service = { path = "../../crates/rome_service" }
 rome_console = { path = "../../crates/rome_console" }

diff --git a/crates/rome_wasm/src/lib.rs b/crates/rome_wasm/src/lib.rs
@@ -40,22 +40,25 @@ impl Workspace {
         &self,
         params: ISupportsFeatureParams,
     ) -> Result<ISupportsFeatureResult, Error> {
-        let params: SupportsFeatureParams = params.into_serde().map_err(into_error)?;
+        let params: SupportsFeatureParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.supports_feature(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(ISupportsFeatureResult::from)
             .map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = updateSettings)]
     pub fn update_settings(&self, params: IUpdateSettingsParams) -> Result<(), Error> {
-        let params: UpdateSettingsParams = params.into_serde().map_err(into_error)?;
+        let params: UpdateSettingsParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner.update_settings(params).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = openFile)]
     pub fn open_file(&self, params: IOpenFileParams) -> Result<(), Error> {
-        let params: OpenFileParams = params.into_serde().map_err(into_error)?;
+        let params: OpenFileParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner.open_file(params).map_err(into_error)
     }
 
@@ -64,9 +67,10 @@ impl Workspace {
         &self,
         params: IGetSyntaxTreeParams,
     ) -> Result<IGetSyntaxTreeResult, Error> {
-        let params: GetSyntaxTreeParams = params.into_serde().map_err(into_error)?;
+        let params: GetSyntaxTreeParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.get_syntax_tree(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(IGetSyntaxTreeResult::from)
             .map_err(into_error)
     }
@@ -76,27 +80,31 @@ impl Workspace {
         &self,
         params: IGetControlFlowGraphParams,
     ) -> Result<String, Error> {
-        let params: GetControlFlowGraphParams = params.into_serde().map_err(into_error)?;
+        let params: GetControlFlowGraphParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner
             .get_control_flow_graph(params)
             .map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = getFormatterIr)]
     pub fn get_formatter_ir(&self, params: IGetFormatterIRParams) -> Result<String, Error> {
-        let params: GetFormatterIRParams = params.into_serde().map_err(into_error)?;
+        let params: GetFormatterIRParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner.get_formatter_ir(params).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = changeFile)]
     pub fn change_file(&self, params: IChangeFileParams) -> Result<(), Error> {
-        let params: ChangeFileParams = params.into_serde().map_err(into_error)?;
+        let params: ChangeFileParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner.change_file(params).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = closeFile)]
     pub fn close_file(&self, params: ICloseFileParams) -> Result<(), Error> {
-        let params: CloseFileParams = params.into_serde().map_err(into_error)?;
+        let params: CloseFileParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         self.inner.close_file(params).map_err(into_error)
     }
 
@@ -105,57 +113,70 @@ impl Workspace {
         &self,
         params: IPullDiagnosticsParams,
     ) -> Result<IPullDiagnosticsResult, Error> {
-        let params: PullDiagnosticsParams = params.into_serde().map_err(into_error)?;
+        let params: PullDiagnosticsParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.pull_diagnostics(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(IPullDiagnosticsResult::from)
             .map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = pullActions)]
     pub fn pull_actions(&self, params: IPullActionsParams) -> Result<IPullActionsResult, Error> {
-        let params: PullActionsParams = params.into_serde().map_err(into_error)?;
+        let params: PullActionsParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.pull_actions(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(IPullActionsResult::from)
             .map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = formatFile)]
     pub fn format_file(&self, params: IFormatFileParams) -> Result<JsValue, Error> {
-        let params: FormatFileParams = params.into_serde().map_err(into_error)?;
+        let params: FormatFileParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.format_file(params).map_err(into_error)?;
-        JsValue::from_serde(&result).map_err(into_error)
+        to_value(&result).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = formatRange)]
     pub fn format_range(&self, params: IFormatRangeParams) -> Result<JsValue, Error> {
-        let params: FormatRangeParams = params.into_serde().map_err(into_error)?;
+        let params: FormatRangeParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.format_range(params).map_err(into_error)?;
-        JsValue::from_serde(&result).map_err(into_error)
+        to_value(&result).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = formatOnType)]
     pub fn format_on_type(&self, params: IFormatOnTypeParams) -> Result<JsValue, Error> {
-        let params: FormatOnTypeParams = params.into_serde().map_err(into_error)?;
+        let params: FormatOnTypeParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.format_on_type(params).map_err(into_error)?;
-        JsValue::from_serde(&result).map_err(into_error)
+        to_value(&result).map_err(into_error)
     }
 
     #[wasm_bindgen(js_name = fixFile)]
     pub fn fix_file(&self, params: IFixFileParams) -> Result<IFixFileResult, Error> {
-        let params: FixFileParams = params.into_serde().map_err(into_error)?;
+        let params: FixFileParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.fix_file(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(IFixFileResult::from)
             .map_err(into_error)
     }
 
     pub fn rename(&self, params: IRenameParams) -> Result<IRenameResult, Error> {
-        let params: RenameParams = params.into_serde().map_err(into_error)?;
+        let params: RenameParams =
+            serde_wasm_bindgen::from_value(params.into()).map_err(into_error)?;
         let result = self.inner.rename(params).map_err(into_error)?;
-        JsValue::from_serde(&result)
+        to_value(&result)
             .map(IRenameResult::from)
             .map_err(into_error)
     }
 }
+
+fn to_value<T: serde::ser::Serialize + ?Sized>(
+    value: &T,
+) -> Result<JsValue, serde_wasm_bindgen::Error> {
+    value.serialize(&serde_wasm_bindgen::Serializer::new().serialize_missing_as_null(true))
+}
diff --git a/crates/rome_wasm/src/utils.rs b/crates/rome_wasm/src/utils.rs
@@ -56,7 +56,8 @@ impl DiagnosticPrinter {
         diagnostic: IDiagnostic,
         printer: fn(&rome_diagnostics::Error) -> PrintDiagnostic<rome_diagnostics::Error>,
     ) -> Result<(), Error> {
-        let diag: Diagnostic = diagnostic.into_serde().map_err(into_error)?;
+        let diag: Diagnostic =
+            serde_wasm_bindgen::from_value(diagnostic.into()).map_err(into_error)?;
         let err = diag
             .with_file_path(&self.file_name)
             .with_file_source_code(&self.file_source);