From 9157e5e32f81f2d6f5b41c624b8d72ca228923af Mon Sep 17 00:00:00 2001
From: Emanuele Stoppa <my.burning@gmail.com>
Date: Sun, 30 Jul 2023 10:22:18 +0100
Subject: [PATCH] feat: add support for `.jsonc` files (#4734)

---
 .github/workflows/pull_request.yml            |   7 +-
 Cargo.toml                                    |   2 +-
 crates/rome_cli/src/configuration.rs          |   6 +-
 crates/rome_cli/tests/commands/format.rs      |  77 +++++++++++-
 .../format_jsonc_files.snap                   |  37 ++++++
 ...treat_known_json_files_as_jsonc_files.snap | 115 ++++++++++++++++++
 .../treats_typescript_json_like_jsonc.snap    |  37 ++++++
 crates/rome_css_parser/Cargo.toml             |   2 +-
 crates/rome_deserialize/src/json.rs           |  10 +-
 crates/rome_js_analyze/Cargo.toml             |  12 +-
 crates/rome_js_transform/Cargo.toml           |  10 +-
 crates/rome_json_analyze/Cargo.toml           |   2 +-
 crates/rome_json_syntax/src/file_source.rs    |   4 +
 .../src/configuration/diagnostics.rs          |   8 +-
 crates/rome_service/src/configuration/mod.rs  |   3 +-
 crates/rome_service/src/file_handlers/json.rs |  18 ++-
 crates/rome_service/src/file_handlers/mod.rs  |  31 +++++
 crates/rome_service/tests/spec_tests.rs       |  10 +-
 crates/rome_test_utils/Cargo.toml             |  33 +++--
 crates/rome_test_utils/src/lib.rs             |   8 +-
 justfile                                      |   4 +-
 21 files changed, 385 insertions(+), 51 deletions(-)
 create mode 100644 crates/rome_cli/tests/snapshots/main_commands_format/format_jsonc_files.snap
 create mode 100644 crates/rome_cli/tests/snapshots/main_commands_format/treat_known_json_files_as_jsonc_files.snap
 create mode 100644 crates/rome_cli/tests/snapshots/main_commands_format/treats_typescript_json_like_jsonc.snap

diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index e40db743ca3..f037080d87a 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -28,8 +28,11 @@ jobs:
         uses: moonrepo/setup-rust@v0
         with:
           components: rustfmt
-      - name: Run rustfmt
-        run: cargo fmt --all --check
+          bins: taplo-cli
+      - name: Run format
+        run: |
+          cargo fmt --all --check
+          taplo fmt -- --locked
 
   lint:
     name: Lint Rust Files
diff --git a/Cargo.toml b/Cargo.toml
index 4bfe4b8d25b..5e86ca561d9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -61,10 +61,10 @@ rome_parser                 = { version = "0.0.1", path = "./crates/rome_parser"
 rome_rowan                  = { version = "0.0.1", path = "./crates/rome_rowan" }
 rome_service                = { path = "./crates/rome_service" }
 rome_suppression            = { version = "0.0.1", path = "./crates/rome_suppression" }
+rome_test_utils             = { path = "./crates/rome_test_utils" }
 rome_text_edit              = { version = "0.0.1", path = "./crates/rome_text_edit" }
 rome_text_size              = { version = "0.0.1", path = "./crates/rome_text_size" }
 tests_macros                = { path = "./crates/tests_macros" }
-rome_test_utils                = { path = "./crates/rome_test_utils" }
 
 # Crates needed in the workspace
 bitflags          = "2.3.1"
diff --git a/crates/rome_cli/src/configuration.rs b/crates/rome_cli/src/configuration.rs
index 437df170af2..7e310486fc1 100644
--- a/crates/rome_cli/src/configuration.rs
+++ b/crates/rome_cli/src/configuration.rs
@@ -5,6 +5,7 @@ use rome_deserialize::json::deserialize_from_json_str;
 use rome_deserialize::Deserialized;
 use rome_diagnostics::{DiagnosticExt, Error, PrintDiagnostic};
 use rome_fs::{FileSystem, OpenOptions};
+use rome_json_parser::JsonParserOptions;
 use rome_service::configuration::diagnostics::CantLoadExtendFile;
 use rome_service::configuration::ConfigurationPayload;
 use rome_service::{
@@ -72,7 +73,10 @@ impl LoadedConfiguration {
 					)
 
 				})?;
-            let deserialized = deserialize_from_json_str::<Configuration>(content.as_str());
+            let deserialized = deserialize_from_json_str::<Configuration>(
+                content.as_str(),
+                JsonParserOptions::default(),
+            );
             deserialized_configurations.push(deserialized)
         }
         Ok(deserialized_configurations)
diff --git a/crates/rome_cli/tests/commands/format.rs b/crates/rome_cli/tests/commands/format.rs
index 4091095bac5..b5256255993 100644
--- a/crates/rome_cli/tests/commands/format.rs
+++ b/crates/rome_cli/tests/commands/format.rs
@@ -1866,7 +1866,7 @@ fn ignore_comments_error_when_allow_comments() {
         Args::from([("format"), file_path.as_os_str().to_str().unwrap()].as_slice()),
     );
 
-    // assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert!(result.is_ok(), "run_cli returned {result:?}");
 
     assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
@@ -1876,3 +1876,78 @@ fn ignore_comments_error_when_allow_comments() {
         result,
     ));
 }
+
+#[test]
+fn format_jsonc_files() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let code = r#"
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	"#;
+    let file_path = Path::new("file.jsonc");
+    fs.insert(file_path.into(), code.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from([("format"), file_path.as_os_str().to_str().unwrap()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "format_jsonc_files",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn treat_known_json_files_as_jsonc_files() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let code = r#"
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	"#;
+    let ts = Path::new("files/typescript.json");
+    fs.insert(ts.into(), code.as_bytes());
+    let eslint = Path::new("files/.eslintrc.json");
+    fs.insert(eslint.into(), code.as_bytes());
+    let jshint = Path::new("files/.jshintrc");
+    fs.insert(jshint.into(), code.as_bytes());
+    let babel = Path::new("files/.babelrc");
+    fs.insert(babel.into(), code.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                ts.as_os_str().to_str().unwrap(),
+                eslint.as_os_str().to_str().unwrap(),
+                jshint.as_os_str().to_str().unwrap(),
+                babel.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "treat_known_json_files_as_jsonc_files",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/format_jsonc_files.snap b/crates/rome_cli/tests/snapshots/main_commands_format/format_jsonc_files.snap
new file mode 100644
index 00000000000..025ce940ad8
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/format_jsonc_files.snap
@@ -0,0 +1,37 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `file.jsonc`
+
+```jsonc
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+# Emitted Messages
+
+```block
+file.jsonc format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/treat_known_json_files_as_jsonc_files.snap b/crates/rome_cli/tests/snapshots/main_commands_format/treat_known_json_files_as_jsonc_files.snap
new file mode 100644
index 00000000000..85a78a41876
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/treat_known_json_files_as_jsonc_files.snap
@@ -0,0 +1,115 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `files/.babelrc`
+
+```babelrc
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+## `files/.eslintrc.json`
+
+```json
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+## `files/.jshintrc`
+
+```jshintrc
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+## `files/typescript.json`
+
+```json
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+# Emitted Messages
+
+```block
+files/typescript.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+files/.eslintrc.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+files/.jshintrc format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+files/.babelrc format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+Compared 4 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/treats_typescript_json_like_jsonc.snap b/crates/rome_cli/tests/snapshots/main_commands_format/treats_typescript_json_like_jsonc.snap
new file mode 100644
index 00000000000..6ac96eeea0b
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/treats_typescript_json_like_jsonc.snap
@@ -0,0 +1,37 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `typescript.json`
+
+```json
+
+/*test*/ [
+
+/* some other comment*/1, 2, 3]
+	
+```
+
+# Emitted Messages
+
+```block
+typescript.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2   │ - /*test*/·[
+    3   │ - 
+    4   │ - /*·some·other·comment*/1,·2,·3]
+    5   │ - → 
+      1 │ + /*test*/·[/*·some·other·comment*/·1,·2,·3]
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_css_parser/Cargo.toml b/crates/rome_css_parser/Cargo.toml
index 5354fafa477..3fb56d1d740 100644
--- a/crates/rome_css_parser/Cargo.toml
+++ b/crates/rome_css_parser/Cargo.toml
@@ -12,8 +12,8 @@ version              = "0.0.1"
 
 [dependencies]
 rome_console          = { workspace = true }
-rome_css_syntax       = { workspace = true }
 rome_css_factory      = { workspace = true }
+rome_css_syntax       = { workspace = true }
 rome_diagnostics      = { workspace = true }
 rome_js_unicode_table = { workspace = true }
 rome_parser           = { workspace = true }
diff --git a/crates/rome_deserialize/src/json.rs b/crates/rome_deserialize/src/json.rs
index dd13fc77c21..e58a65f224b 100644
--- a/crates/rome_deserialize/src/json.rs
+++ b/crates/rome_deserialize/src/json.rs
@@ -587,9 +587,10 @@ pub fn with_only_known_variants(
 ///     }
 /// }
 ///
+///  use rome_json_parser::JsonParserOptions;
 /// # fn main() -> Result<(), DeserializationDiagnostic> {
 /// let source = r#"{ "lorem": true }"#;
-///  let deserialized = deserialize_from_json_str::<NewConfiguration>(&source);
+///  let deserialized = deserialize_from_json_str::<NewConfiguration>(&source, JsonParserOptions::default());
 ///  assert!(!deserialized.has_errors());
 ///  assert_eq!(deserialized.into_deserialized(), NewConfiguration { lorem: true });
 /// # Ok(())
@@ -597,13 +598,16 @@ pub fn with_only_known_variants(
 ///
 ///
 /// ```
-pub fn deserialize_from_json_str<Output>(source: &str) -> Deserialized<Output>
+pub fn deserialize_from_json_str<Output>(
+    source: &str,
+    options: JsonParserOptions,
+) -> Deserialized<Output>
 where
     Output: Default + VisitJsonNode + JsonDeserialize,
 {
     let mut output = Output::default();
     let mut diagnostics = vec![];
-    let parse = parse_json(source, JsonParserOptions::default());
+    let parse = parse_json(source, options);
     Output::deserialize_from_ast(&parse.tree(), &mut output, &mut diagnostics);
     let mut errors = parse
         .into_diagnostics()
diff --git a/crates/rome_js_analyze/Cargo.toml b/crates/rome_js_analyze/Cargo.toml
index 3bb79b7d32b..1b0f661bcaf 100644
--- a/crates/rome_js_analyze/Cargo.toml
+++ b/crates/rome_js_analyze/Cargo.toml
@@ -31,12 +31,12 @@ serde_json            = { workspace = true }
 smallvec              = { workspace = true }
 
 [dev-dependencies]
-countme          = { workspace = true, features = ["enable"] }
-insta            = { workspace = true, features = ["glob"] }
-rome_js_parser   = { workspace = true, features = ["tests"] }
-rome_text_edit   = { workspace = true }
-tests_macros     = { workspace = true }
-rome_test_utils =  { workspace = true }
+countme         = { workspace = true, features = ["enable"] }
+insta           = { workspace = true, features = ["glob"] }
+rome_js_parser  = { workspace = true, features = ["tests"] }
+rome_test_utils = { workspace = true }
+rome_text_edit  = { workspace = true }
+tests_macros    = { workspace = true }
 
 [features]
 schema = ["schemars", "rome_deserialize/schema"]
diff --git a/crates/rome_js_transform/Cargo.toml b/crates/rome_js_transform/Cargo.toml
index 81ff37f6cba..2efa2cc0512 100644
--- a/crates/rome_js_transform/Cargo.toml
+++ b/crates/rome_js_transform/Cargo.toml
@@ -11,17 +11,17 @@ version              = "0.1.0"
 [dependencies]
 lazy_static      = { workspace = true }
 rome_analyze     = { workspace = true }
+rome_console     = { workspace = true }
 rome_diagnostics = { workspace = true }
 rome_js_factory  = { workspace = true }
 rome_js_syntax   = { workspace = true }
 rome_rowan       = { workspace = true }
-rome_console = {workspace= true}
 
 
 [dev-dependencies]
+insta             = { workspace = true }
+rome_analyze      = { workspace = true }
 rome_js_formatter = { workspace = true }
 rome_js_parser    = { workspace = true }
-rome_analyze =  { workspace = true }
-rome_test_utils = { workspace = true }
-tests_macros= { workspace = true }
-insta = { workspace = true }
+rome_test_utils   = { workspace = true }
+tests_macros      = { workspace = true }
diff --git a/crates/rome_json_analyze/Cargo.toml b/crates/rome_json_analyze/Cargo.toml
index 5f551556d5e..a4f98b13a65 100644
--- a/crates/rome_json_analyze/Cargo.toml
+++ b/crates/rome_json_analyze/Cargo.toml
@@ -21,5 +21,5 @@ insta             = { workspace = true, features = ["glob"] }
 rome_json_factory = { workspace = true }
 rome_json_parser  = { workspace = true }
 rome_service      = { workspace = true }
+rome_test_utils   = { workspace = true }
 tests_macros      = { workspace = true }
-rome_test_utils = { workspace = true }
diff --git a/crates/rome_json_syntax/src/file_source.rs b/crates/rome_json_syntax/src/file_source.rs
index b90c22030b9..817fa5e0c82 100644
--- a/crates/rome_json_syntax/src/file_source.rs
+++ b/crates/rome_json_syntax/src/file_source.rs
@@ -28,6 +28,10 @@ impl JsonFileSource {
             variant: JsonVariant::Jsonc,
         }
     }
+
+    pub const fn is_jsonc(&self) -> bool {
+        matches!(self.variant, JsonVariant::Jsonc)
+    }
 }
 
 impl<'a> FileSource<'a, JsonLanguage> for JsonFileSource {}
diff --git a/crates/rome_service/src/configuration/diagnostics.rs b/crates/rome_service/src/configuration/diagnostics.rs
index a605ae5bbde..ad843a82108 100644
--- a/crates/rome_service/src/configuration/diagnostics.rs
+++ b/crates/rome_service/src/configuration/diagnostics.rs
@@ -289,6 +289,7 @@ mod test {
     use crate::{Configuration, MatchOptions, Matcher};
     use rome_deserialize::json::deserialize_from_json_str;
     use rome_diagnostics::{print_diagnostic_to_string, DiagnosticExt, Error};
+    use rome_json_parser::JsonParserOptions;
 
     fn snap_diagnostic(test_name: &str, diagnostic: Error) {
         let content = print_diagnostic_to_string(&diagnostic);
@@ -340,7 +341,8 @@ mod test {
     #[test]
     fn deserialization_error() {
         let content = "{ \n\n\"formatter\" }";
-        let result = deserialize_from_json_str::<Configuration>(content);
+        let result =
+            deserialize_from_json_str::<Configuration>(content, JsonParserOptions::default());
 
         assert!(result.has_errors());
         for diagnostic in result.into_diagnostics() {
@@ -363,6 +365,8 @@ mod test {
     }
   }
 }"#;
-        let _result = deserialize_from_json_str::<Configuration>(content).into_deserialized();
+        let _result =
+            deserialize_from_json_str::<Configuration>(content, JsonParserOptions::default())
+                .into_deserialized();
     }
 }
diff --git a/crates/rome_service/src/configuration/mod.rs b/crates/rome_service/src/configuration/mod.rs
index 62574d4ff92..48f312733f1 100644
--- a/crates/rome_service/src/configuration/mod.rs
+++ b/crates/rome_service/src/configuration/mod.rs
@@ -348,7 +348,8 @@ pub fn load_config(
             directory_path,
             file_path,
         } = auto_search_result;
-        let deserialized = deserialize_from_json_str::<Configuration>(&content);
+        let deserialized =
+            deserialize_from_json_str::<Configuration>(&content, JsonParserOptions::default());
         Ok(Some(ConfigurationPayload {
             deserialized,
             configuration_file_path: file_path,
diff --git a/crates/rome_service/src/file_handlers/json.rs b/crates/rome_service/src/file_handlers/json.rs
index 6103c344a49..0f0b3e4bf1c 100644
--- a/crates/rome_service/src/file_handlers/json.rs
+++ b/crates/rome_service/src/file_handlers/json.rs
@@ -26,7 +26,7 @@ use rome_json_syntax::{JsonFileSource, JsonLanguage, JsonRoot, JsonSyntaxNode};
 use rome_parser::AnyParse;
 use rome_rowan::{AstNode, FileSource, NodeCache};
 use rome_rowan::{TextRange, TextSize, TokenAtOffset};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 impl Language for JsonLanguage {
     type FormatterSettings = ();
@@ -89,6 +89,14 @@ impl ExtensionHandler for JsonFileHandler {
     }
 }
 
+fn is_file_allowed_as_jsonc(path: &Path) -> bool {
+    path.file_name()
+        .and_then(|f| f.to_str())
+        .map(|f| super::Language::ALLOWED_FILES.contains(&f))
+        // default is false
+        .unwrap_or_default()
+}
+
 fn parse(
     rome_path: &RomePath,
     language_hint: LanguageId,
@@ -97,15 +105,17 @@ fn parse(
     cache: &mut NodeCache,
 ) -> AnyParse {
     let parser = &settings.as_ref().languages.json.parser;
-    let options: JsonParserOptions = JsonParserOptions {
-        allow_comments: parser.allow_comments,
-    };
     let source_type =
         JsonFileSource::try_from(rome_path.as_path()).unwrap_or_else(|_| match language_hint {
             LanguageId::Json => JsonFileSource::json(),
             LanguageId::Jsonc => JsonFileSource::jsonc(),
             _ => JsonFileSource::json(),
         });
+    let options: JsonParserOptions = JsonParserOptions {
+        allow_comments: parser.allow_comments
+            || source_type.is_jsonc()
+            || is_file_allowed_as_jsonc(rome_path),
+    };
     let parse = rome_json_parser::parse_json_with_cache(text, cache, options);
     let root = parse.syntax();
     let diagnostics = parse.into_diagnostics();
diff --git a/crates/rome_service/src/file_handlers/mod.rs b/crates/rome_service/src/file_handlers/mod.rs
index 59b9c7151b8..80d2866fde9 100644
--- a/crates/rome_service/src/file_handlers/mod.rs
+++ b/crates/rome_service/src/file_handlers/mod.rs
@@ -44,6 +44,23 @@ pub enum Language {
 }
 
 impl Language {
+    /// Files that can be bypassed, because correctly handled by the JSON parser
+    pub(crate) const ALLOWED_FILES: &'static [&'static str; 13] = &[
+        "typescript.json",
+        "tslint.json",
+        "babel.config.json",
+        ".babelrc.json",
+        ".ember-cli",
+        "typedoc.json",
+        ".eslintrc.json",
+        ".eslintrc",
+        ".jsfmtrc",
+        ".jshintrc",
+        ".swcrc",
+        ".hintrc",
+        ".babelrc",
+    ];
+
     /// Returns the language corresponding to this file extension
     pub fn from_extension(s: &str) -> Self {
         match s.to_lowercase().as_str() {
@@ -52,10 +69,19 @@ impl Language {
             "ts" | "mts" | "cts" => Language::TypeScript,
             "tsx" => Language::TypeScriptReact,
             "json" => Language::Json,
+            "jsonc" => Language::Jsonc,
             _ => Language::Unknown,
         }
     }
 
+    pub fn from_known_filename(s: &str) -> Self {
+        if Self::ALLOWED_FILES.contains(&s.to_lowercase().as_str()) {
+            Language::Jsonc
+        } else {
+            Language::Unknown
+        }
+    }
+
     /// Returns the language corresponding to the file path
     pub fn from_path(path: &Path) -> Self {
         path.extension()
@@ -77,6 +103,7 @@ impl Language {
             "javascriptreact" => Language::JavaScriptReact,
             "typescriptreact" => Language::TypeScriptReact,
             "json" => Language::Json,
+            "jsonc" => Language::Jsonc,
             _ => Language::Unknown,
         }
     }
@@ -294,6 +321,10 @@ impl Features {
             .extension()
             .and_then(OsStr::to_str)
             .map(Language::from_extension)
+            .or(rome_path
+                .file_name()
+                .and_then(OsStr::to_str)
+                .map(Language::from_known_filename))
             .unwrap_or_default()
     }
 
diff --git a/crates/rome_service/tests/spec_tests.rs b/crates/rome_service/tests/spec_tests.rs
index 9eb8832bc38..3eef4fdb1b0 100644
--- a/crates/rome_service/tests/spec_tests.rs
+++ b/crates/rome_service/tests/spec_tests.rs
@@ -1,5 +1,6 @@
 use rome_deserialize::json::deserialize_from_json_str;
 use rome_diagnostics::{print_diagnostic_to_string, DiagnosticExt};
+use rome_json_parser::JsonParserOptions;
 use rome_service::Configuration;
 use std::ffi::OsStr;
 use std::fs::read_to_string;
@@ -14,7 +15,14 @@ fn run_invalid_configurations(input: &'static str, _: &str, _: &str, _: &str) {
         .unwrap_or_else(|err| panic!("failed to read {:?}: {:?}", input_file, err));
 
     let result = match extension {
-        "json" => deserialize_from_json_str::<Configuration>(input_code.as_str()),
+        "json" => deserialize_from_json_str::<Configuration>(
+            input_code.as_str(),
+            JsonParserOptions::default(),
+        ),
+        "jsonc" => deserialize_from_json_str::<Configuration>(
+            input_code.as_str(),
+            JsonParserOptions::default().with_allow_comments(),
+        ),
         _ => {
             panic!("Extension not supported");
         }
diff --git a/crates/rome_test_utils/Cargo.toml b/crates/rome_test_utils/Cargo.toml
index 7d24ffa7e73..ed4f1c74d12 100644
--- a/crates/rome_test_utils/Cargo.toml
+++ b/crates/rome_test_utils/Cargo.toml
@@ -1,25 +1,24 @@
 [package]
-name = "rome_test_utils"
-version = "0.1.0"
 edition = "2021"
+name    = "rome_test_utils"
 publish = false
+version = "0.1.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rome_js_parser = {workspace = true }
-rome_json_parser = {workspace = true }
-rome_js_syntax = {workspace = true }
-rome_json_syntax = {workspace = true }
-rome_analyze = {workspace = true }
-rome_rowan = {workspace = true }
-rome_diagnostics = {workspace = true }
-rome_service = {workspace = true }
-rome_console = {workspace = true }
-rome_deserialize = {workspace = true }
-countme = { workspace = true, features = ["enable"] }
-similar = { version = "2.2.1" }
+countme          = { workspace = true, features = ["enable"] }
 json_comments    = "0.2.1"
-serde = { workspace = true }
-serde_json = { workspace = true }
-
+rome_analyze     = { workspace = true }
+rome_console     = { workspace = true }
+rome_deserialize = { workspace = true }
+rome_diagnostics = { workspace = true }
+rome_js_parser   = { workspace = true }
+rome_js_syntax   = { workspace = true }
+rome_json_parser = { workspace = true }
+rome_json_syntax = { workspace = true }
+rome_rowan       = { workspace = true }
+rome_service     = { workspace = true }
+serde            = { workspace = true }
+serde_json       = { workspace = true }
+similar          = { version = "2.2.1" }
diff --git a/crates/rome_test_utils/src/lib.rs b/crates/rome_test_utils/src/lib.rs
index 0995286b086..75d26398608 100644
--- a/crates/rome_test_utils/src/lib.rs
+++ b/crates/rome_test_utils/src/lib.rs
@@ -4,7 +4,7 @@ use rome_console::fmt::{Formatter, Termcolor};
 use rome_console::markup;
 use rome_diagnostics::termcolor::Buffer;
 use rome_diagnostics::{DiagnosticExt, Error, PrintDiagnostic};
-use rome_json_parser::ParseDiagnostic;
+use rome_json_parser::{JsonParserOptions, ParseDiagnostic};
 use rome_rowan::{SyntaxKind, SyntaxNode, SyntaxSlot};
 use rome_service::configuration::to_analyzer_configuration;
 use rome_service::settings::{Language, WorkspaceSettings};
@@ -35,8 +35,10 @@ pub fn create_analyzer_options(
     // that configures that specific rule.
     let options_file = input_file.with_extension("options.json");
     if let Ok(json) = std::fs::read_to_string(options_file.clone()) {
-        let deserialized =
-            rome_deserialize::json::deserialize_from_json_str::<Configuration>(json.as_str());
+        let deserialized = rome_deserialize::json::deserialize_from_json_str::<Configuration>(
+            json.as_str(),
+            JsonParserOptions::default(),
+        );
         if deserialized.has_errors() {
             diagnostics.extend(
                 deserialized
diff --git a/justfile b/justfile
index fd5ba046098..f37c2d35286 100644
--- a/justfile
+++ b/justfile
@@ -73,11 +73,11 @@ _touch file:
 
 # Run tests of all crates
 test:
-	cargo nextest run
+	cargo nextest run --no-fail-fast
 
 # Run tests for the crate passed as argument e.g. just test-create rome_cli
 test-crate name:
-	cargo nextest run -E 'package({{name}})'
+	cargo nextest run -E 'package({{name}})' --no-fail-fast
 
 # Run doc tests
 test-doc: