refactor: rm self cell

Author: stormslowly

src/cache.rs

@@ -15,8 +15,10 @@ use rustc_hash::FxHasher;
 use tokio::sync::OnceCell as OnceLock;
 
 use crate::{
-  context::ResolveContext as Ctx, package_json::PackageJson, path::PathUtil, FileMetadata,
-  FileSystem, ResolveError, ResolveOptions, TsConfig,
+  context::ResolveContext as Ctx,
+  package_json::{off_to_location, PackageJson},
+  path::PathUtil,
+  FileMetadata, FileSystem, JSONError, ResolveError, ResolveOptions, TsConfig,
 };
 
 #[derive(Default)]
@@ -319,12 +321,32 @@ impl CachedPathImpl {
         } else {
           package_json_path.clone()
         };
-        PackageJson::parse(package_json_path.clone(), real_path, package_json_string)
-          .map(Arc::new)
-          .map(Some)
+        match PackageJson::parse(package_json_path.clone(), real_path, package_json_string) {
+          Ok(v) => Ok(Some(Arc::new(v))),
+          Err(parse_err) => {
+            let package_json_path = self.path.join("package.json");
+            let package_json_string = match fs.read_to_string(&package_json_path).await {
+              Ok(c) => c,
+              Err(io_err) => {
+                return Err(ResolveError::from(io_err));
+              }
+            };
+
+            let (line, column) = off_to_location(&package_json_string, parse_err.index());
+
+            Err(ResolveError::JSON(JSONError {
+              path: package_json_path,
+              message: format!("Parsing error: {:?}", parse_err.error()),
+              line,
+              column,
+              content: Some(package_json_string),
+            }))
+          }
+        }
       })
       .await
       .cloned();
+
     // https://github.com/webpack/enhanced-resolve/blob/58464fc7cb56673c9aa849e68e6300239601e615/lib/DescriptionFileUtils.js#L68-L82
     match &result {
       Ok(Some(package_json)) => {

src/lib.rs

@@ -1772,7 +1772,7 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
                         && (pattern_trailer.is_empty()
                         || (match_key.len() >= expansion_key.len()
                         && match_key.ends_with(pattern_trailer)))
-                        && Self::pattern_key_compare(&best_key, &expansion_key).is_gt()
+                        && Self::pattern_key_compare(&best_key, expansion_key).is_gt()
           {
             // 1. Let target be the value of matchObj[expansionKey].
             best_target = Some(target);

src/package_json/mod.rs

@@ -36,3 +36,24 @@ pub enum SideEffects {
   String(String),
   Array(Vec<String>),
 }
+
+pub fn off_to_location(json: &str, offset: usize) -> (usize, usize) {
+  let mut line = 0;
+  let mut col = 0;
+  let mut current_offset = 0;
+  for ch in json.chars() {
+    let b = ch.len_utf8();
+    current_offset += b;
+    if ch == '\n' {
+      line += 1;
+      col = 0;
+    } else {
+      col += b;
+    }
+
+    if current_offset >= offset {
+      break;
+    }
+  }
+  (line + 1, col + 1)
+}

src/package_json/simd.rs

@@ -3,14 +3,16 @@
 //! Code related to export field are copied from [Parcel's resolver](https://github.com/parcel-bundler/parcel/blob/v2/packages/utils/node-resolver-rs/src/package_json.rs)
 
 use std::{
-  fmt::Debug,
+  fmt::{Debug, Formatter},
+  marker::PhantomData,
   path::{Path, PathBuf},
 };
 
-use self_cell::self_cell;
-use simd_json::{borrowed::Value, prelude::*, to_borrowed_value};
+use simd_json::{
+  borrowed::Value, prelude::*, to_borrowed_value, BorrowedValue, Error as ParseError,
+};
 
-use crate::{path::PathUtil, JSONError, ResolveError};
+use crate::{path::PathUtil, ResolveError};
 
 pub type JSONMap<'a> = simd_json::borrowed::Object<'a>;
 
@@ -20,19 +22,44 @@ pub use simd_json::BorrowedValue as JSONValue;
 
 use crate::package_json::{ModuleType, SideEffects};
 
-self_cell!(
-    struct JSONCell {
-        owner: Vec<u8>,
+pub struct JSONCell {
+  value: BorrowedValue<'static>,
+  buf: Vec<u8>,
+  _invariant: PhantomData<&'static str>,
+}
 
-        #[covariant]
-        dependent: JSONValue,
-    }
-    impl {Debug}
-);
+impl JSONCell {
+  pub fn try_new(mut buf: Vec<u8>) -> Result<Self, ParseError> {
+    let value = to_borrowed_value(&mut buf)?;
+    // SAFETY: This is safe because `buf` is owned by the `JSONCell` struct,
+    let value = unsafe { std::mem::transmute::<BorrowedValue<'_>, BorrowedValue<'static>>(value) };
+
+    Ok(Self {
+      value,
+      buf,
+      _invariant: PhantomData,
+    })
+  }
+
+  pub fn borrow_dependent<'a>(&'a self) -> &'a JSONValue<'a> {
+    &self.value
+  }
+}
+
+impl Debug for JSONCell {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    let str = String::from_utf8_lossy(&self.buf);
+    f.write_fmt(format_args!("JSONCell({str})"))
+  }
+}
 
 impl Default for JSONCell {
   fn default() -> Self {
-    Self::new(Vec::new(), |_data| JSONValue::Static(StaticNode::Null))
+    Self {
+      value: JSONValue::Static(StaticNode::Null),
+      buf: Vec::new(),
+      _invariant: PhantomData,
+    }
   }
 }
 
@@ -70,27 +97,8 @@ pub struct PackageJson {
 impl PackageJson {
   /// # Panics
   /// # Errors
-  pub(crate) fn parse(
-    path: PathBuf,
-    realpath: PathBuf,
-    json: Vec<u8>,
-  ) -> Result<Self, ResolveError> {
-    let json_cell = JSONCell::try_new(json, |v| {
-      // SAFETY: We have exclusive ownership of the Vec<u8>, so it's safe to cast to mutable.
-      let slice = unsafe { std::slice::from_raw_parts_mut(v.as_ptr().cast_mut(), v.len()) };
-
-      to_borrowed_value(slice).map_err(|e| {
-        let content = String::from_utf8_lossy(v);
-        let (line, column) = offset_to_location(&content, e.index());
-        ResolveError::JSON(JSONError {
-          path: path.clone(),
-          message: format!("JSON parse error: {:?}", e.error()),
-          line,
-          column,
-          content: Some(content.to_string()),
-        })
-      })
-    })?;
+  pub(crate) fn parse(path: PathBuf, realpath: PathBuf, json: Vec<u8>) -> Result<Self, ParseError> {
+    let json_cell = JSONCell::try_new(json)?;
 
     let mut package_json = Self::default();
     if let Some(json_object) = json_cell.borrow_dependent().as_object() {
@@ -302,28 +310,6 @@ impl PackageJson {
   }
 }
 
-fn offset_to_location(json: &str, offset: usize) -> (usize, usize) {
-  let mut line = 0;
-  let mut col = 0;
-  let mut current_offset = 0;
-  for ch in json.chars() {
-    let b = ch.len_utf8();
-    current_offset += b;
-    if ch == '\n' {
-      line += 1;
-      col = 0;
-    } else {
-      col += b;
-    }
-
-    if current_offset >= offset {
-      break;
-    }
-  }
-  // zero-based to one-based
-  (line + 1, col + 1)
-}
-
 impl<'a> TryFrom<&'a JSONValue<'a>> for SideEffects {
   type Error = &'static str;
   fn try_from(value: &'a JSONValue<'a>) -> Result<Self, Self::Error> {