fix(package_json): re-read file for serde_json fallback in simd implementation (#808)

## Summary

When `simd_json` fails to parse a `package.json` file, the fallback to
`serde_json` now re-reads the file from disk instead of using a cloned
byte buffer. This ensures accurate error messages with correct line and
column numbers.

## Problem

Previously, when `simd_json` parsing failed, the code used a cloned byte
buffer for the `serde_json` fallback. However, `simd_json` mutates the
buffer in-place during parsing, so even a cloned buffer taken before
parsing might not reflect the original file content if the mutation
happened before the clone.

## Solution

- Updated `PackageJson::parse` to accept a `FileSystem` parameter
- Modified the error fallback to re-read the file using
`fs.read_to_string(&realpath)` before parsing with `serde_json`
- This guarantees that error messages are based on the original,
unmodified file content

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: Boshen

benches/resolver.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
-use oxc_resolver::PackageJson;
+use oxc_resolver::{FileSystem as FileSystemTrait, FileSystemOs, PackageJson};
 use rayon::prelude::*;
 
 mod memory_fs;
@@ -356,6 +356,10 @@ fn bench_package_json_deserialization(c: &mut Criterion) {
 
     let test_path = PathBuf::from("/test/package.json");
     let test_realpath = test_path.clone();
+    #[cfg(feature = "yarn_pnp")]
+    let fs = FileSystemOs::new(false);
+    #[cfg(not(feature = "yarn_pnp"))]
+    let fs = FileSystemOs::new();
 
     let data = [
         ("small", small_json.to_string()),
@@ -369,7 +373,7 @@ fn bench_package_json_deserialization(c: &mut Criterion) {
             b.iter_with_setup_wrapper(|runner| {
                 let json = json.clone();
                 runner.run(|| {
-                    PackageJson::parse(test_path.clone(), test_realpath.clone(), json)
+                    PackageJson::parse(&fs, test_path.clone(), test_realpath.clone(), json)
                         .expect("Failed to parse JSON");
                 });
             });

src/cache/cache_impl.rs

@@ -120,7 +120,7 @@ impl<Fs: FileSystem> Cache<Fs> {
                 } else {
                     package_json_path.clone()
                 };
-                PackageJson::parse(package_json_path, real_path, package_json_string)
+                PackageJson::parse(&self.fs, package_json_path, real_path, package_json_string)
                     .map(|package_json| Some(Arc::new(package_json)))
                     .map_err(ResolveError::Json)
             })

src/package_json/serde.rs

@@ -10,7 +10,7 @@ use std::{
 use serde_json::Value;
 
 use super::{ImportsExportsKind, PackageType, SideEffects};
-use crate::{JSONError, ResolveError, path::PathUtil};
+use crate::{FileSystem, JSONError, ResolveError, path::PathUtil};
 
 /// Serde implementation for the deserialized `package.json`.
 ///
@@ -220,7 +220,12 @@ impl PackageJson {
     /// Parse a package.json file from JSON string
     ///
     /// # Errors
-    pub fn parse(path: PathBuf, realpath: PathBuf, json: String) -> Result<Self, JSONError> {
+    pub fn parse<Fs: FileSystem>(
+        _fs: &Fs,
+        path: PathBuf,
+        realpath: PathBuf,
+        json: String,
+    ) -> Result<Self, JSONError> {
         // Strip BOM
         let json_string = if json.starts_with('\u{FEFF}') {
             json.trim_start_matches('\u{FEFF}')

src/package_json/simd.rs

@@ -7,17 +7,18 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use self_cell::MutBorrow;
 use simd_json::{BorrowedValue, prelude::*};
 
 use super::{ImportsExportsKind, PackageType, SideEffects};
-use crate::{JSONError, ResolveError, path::PathUtil};
+use crate::{FileSystem, JSONError, ResolveError, path::PathUtil};
 
 // Use simd_json's Object type which handles the hasher correctly based on features
 type BorrowedObject<'a> = simd_json::value::borrowed::Object<'a>;
 
 self_cell::self_cell! {
     struct PackageJsonCell {
-        owner: Vec<u8>,
+        owner: MutBorrow<Vec<u8>>,
 
         #[covariant]
         dependent: BorrowedValue,
@@ -253,7 +254,12 @@ impl PackageJson {
     ///
     /// # Panics
     /// # Errors
-    pub fn parse(path: PathBuf, realpath: PathBuf, json: String) -> Result<Self, JSONError> {
+    pub fn parse<Fs: FileSystem>(
+        fs: &Fs,
+        path: PathBuf,
+        realpath: PathBuf,
+        json: String,
+    ) -> Result<Self, JSONError> {
         // Strip BOM in place by replacing with spaces (no reallocation)
         let mut json_bytes = json.into_bytes();
         if json_bytes.starts_with(b"\xEF\xBB\xBF") {
@@ -266,18 +272,34 @@ impl PackageJson {
         super::check_if_empty(&json_bytes, path.clone())?;
 
         // Create the self-cell with the JSON bytes and parsed BorrowedValue
-        let cell = PackageJsonCell::try_new(json_bytes.clone(), |bytes| {
-            // We need a mutable slice from our owned data
-            // SAFETY: We're creating a mutable reference to the owned data.
-            // The self_cell ensures this reference is valid for the lifetime of the cell.
-            let slice =
-                unsafe { std::slice::from_raw_parts_mut(bytes.as_ptr().cast_mut(), bytes.len()) };
-            simd_json::to_borrowed_value(slice)
+        let cell = PackageJsonCell::try_new(MutBorrow::new(json_bytes), |bytes| {
+            // Use MutBorrow to safely get mutable access for simd_json parsing
+            simd_json::to_borrowed_value(bytes.borrow_mut())
         })
         .map_err(|simd_error| {
-            // Fallback: parse with serde_json to get detailed error information
-            // simd_json doesn't provide line/column info, so we re-parse to get it
-            match serde_json::from_slice::<serde_json::Value>(&json_bytes) {
+            // Fallback: re-read the file and parse with serde_json to get detailed error information
+            // We re-read because simd_json may have mutated the buffer during its failed parse attempt
+            // simd_json doesn't provide line/column info, so we use serde_json for better error messages
+            let fallback_result = fs
+                .read_to_string(&realpath)
+                .map_err(|io_error| JSONError {
+                    path: path.clone(),
+                    message: format!("Failed to re-read file for error reporting: {io_error}"),
+                    line: 0,
+                    column: 0,
+                })
+                .and_then(|content| {
+                    serde_json::from_str::<serde_json::Value>(&content).map_err(|serde_error| {
+                        JSONError {
+                            path: path.clone(),
+                            message: serde_error.to_string(),
+                            line: serde_error.line(),
+                            column: serde_error.column(),
+                        }
+                    })
+                });
+
+            match fallback_result {
                 Ok(_) => {
                     // serde_json succeeded but simd_json failed - this shouldn't happen
                     // for valid JSON, but could indicate simd_json is more strict
@@ -288,15 +310,7 @@ impl PackageJson {
                         column: 0,
                     }
                 }
-                Err(serde_error) => {
-                    // Both parsers failed - use serde_json's detailed error
-                    JSONError {
-                        path: path.clone(),
-                        message: serde_error.to_string(),
-                        line: serde_error.line(),
-                        column: serde_error.column(),
-                    }
-                }
+                Err(error) => error,
             }
         })?;