refactor(es/preset-env): Use phf for corejs3 entry (#10712)

**Description:**

This is a follow-up to #10684. I
simply chose an example to experiment with.

I did some simple testing and I believe there is no large regression in
single query performance.
```
// before
es/preset-env/entry/import
                        time:   [531.47 ns 532.42 ns 533.55 ns]

// after                        
es/preset-env/entry/import
                        time:   [549.62 ns 551.02 ns 552.55 ns]
```

Since we do dedup when packing strings, it is more compact than the
original json and has some size optimization.

```
// before
16397965	../../target/release/deps/polyfills-d11a2ed3340dd897

// after
16070261	../../target/release/deps/polyfills-4b49b166ca0322eb
```

Since `../../data/core-js-compat/entries.json` is 500k large, I believe it also saves close to 500k of memory.

Author: quininer

Cargo.lock

@@ -125,6 +125,9 @@ resolver = "2"
   wasmer                    = { version = "6.0.0", default-features = false }
   wasmer-wasix              = { version = "0.600.0", default-features = false }
 
+  precomputed-map           = "0.2"
+  foldhash                  = "0.1"
+
   [workspace.metadata.cargo-shear]
   # `serde` is used when #[ast_node] is expanded
   # the rests are used for enabling features
@@ -139,7 +142,6 @@ resolver = "2"
     "swc_ecma_utils",
   ]
 
-
 [profile.release]
 lto = true
 

Cargo.toml

@@ -23,6 +23,10 @@ serde      = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true }
 
 preset_env_base = { version = "4.0.1", path = "../preset_env_base" }
+
+precomputed-map = { workspace = true }
+foldhash        = { workspace = true }
+
 rustc-hash = { workspace = true }
 string_enum = { version = "1.0.2", path = "../string_enum" }
 swc_atoms = { version = "6.0.1", path = "../swc_atoms" }
@@ -35,6 +39,12 @@ swc_ecma_transforms = { version = "23.0.1", path = "../swc_ecma_transforms", fea
 swc_ecma_utils = { version = "18.0.3", path = "../swc_ecma_utils" }
 swc_ecma_visit = { version = "13.0.0", path = "../swc_ecma_visit" }
 
+[build-dependencies]
+anyhow     = { workspace = true }
+serde_json = { workspace = true }
+precomputed-map = { workspace = true, features = ["builder"] }
+foldhash        = { workspace = true }
+
 [dev-dependencies]
 codspeed-criterion-compat = { workspace = true }
 pretty_assertions         = { workspace = true }

crates/swc_ecma_preset_env/Cargo.toml

@@ -0,0 +1,135 @@
+use std::{
+    collections::{BTreeMap, HashMap},
+    fs,
+    io::{self, Write},
+    path::Path,
+};
+
+use anyhow::Context;
+
+fn main() -> anyhow::Result<()> {
+    es_preset_env_corejs3_entry()
+}
+
+fn es_preset_env_corejs3_entry() -> anyhow::Result<()> {
+    const SEED: u64 = 16416001479773392852;
+
+    let crate_dir = std::env::var("CARGO_MANIFEST_DIR")?;
+    let crate_dir = Path::new(&crate_dir);
+
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_dir);
+    let out_dir = out_dir.join("corejs3_entries");
+
+    let entry_path = crate_dir.join("data/core-js-compat/entries.json");
+    println!("cargo::rerun-if-changed={}", entry_path.display());
+
+    let entry_data = fs::read_to_string(entry_path)?;
+    let entry_data: BTreeMap<&str, Vec<&str>> =
+        serde_json::from_str(&entry_data).context("failed to parse entries.json from core js 3")?;
+    let (keys, values): (Vec<_>, Vec<_>) = entry_data.into_iter().unzip();
+
+    let mut strpool = StrPool::default();
+    let mut values_strid = Vec::new();
+    let mut values_index = Vec::new();
+    for list in values {
+        let start: u32 = values_strid.len().try_into().unwrap();
+
+        for s in list {
+            values_strid.push(strpool.insert(s));
+        }
+        let end: u32 = values_strid.len().try_into().unwrap();
+        values_index.push(start..end);
+    }
+
+    let mapout = precomputed_map::builder::MapBuilder::<&str>::new()
+        .set_seed(SEED)
+        .set_hash(&|seed, &v| {
+            use std::hash::{Hash, Hasher};
+
+            let mut hasher =
+                foldhash::fast::FoldHasher::with_seed(seed, foldhash::SharedSeed::global_fixed());
+            v.as_bytes().hash(&mut hasher);
+            hasher.finish()
+        })
+        .set_next_seed(|seed, c| seed + c)
+        .build(&keys)?;
+
+    if let Some(seed) = mapout.seed().filter(|&seed| seed != SEED) {
+        println!(
+            "cargo::warning=The seed has changed, please update the seed to {seed} for faster \
+             builds"
+        );
+    }
+
+    // clean file
+    {
+        fs::remove_dir_all(&out_dir).or_else(|err| match err.kind() {
+            io::ErrorKind::NotFound => Ok(()),
+            _ => Err(err),
+        })?;
+        fs::create_dir(&out_dir)?;
+    }
+
+    let mut u8seq = precomputed_map::builder::U8SeqWriter::new(
+        "PrecomputedU8Seq".into(),
+        out_dir.join("u8.bin"),
+    );
+    let mut u32seq = precomputed_map::builder::U32SeqWriter::new(
+        "PrecomputedU32Seq".into(),
+        out_dir.join("u32.bin"),
+    );
+
+    let mut builder = precomputed_map::builder::CodeBuilder::new(
+        "Corejs3Entries".into(),
+        "SwcFold".into(),
+        &mut u8seq,
+        &mut u32seq,
+    );
+
+    let k = builder.create_bytes_position_seq("EntryKeys".into(), mapout.reorder(&keys))?;
+    builder.create_u32_seq("EntryValuesStringId".into(), values_strid.iter().copied())?;
+    mapout.create_map("ENTRY_INDEX".into(), k, &mut builder)?;
+
+    let mut codeout = fs::File::create(out_dir.join("lib.rs"))?;
+    builder.codegen(&mut codeout)?;
+    u8seq.codegen(&mut codeout)?;
+    u32seq.codegen(&mut codeout)?;
+
+    fs::write(out_dir.join("str.bin"), strpool.pool.as_bytes())?;
+
+    writeln!(
+        codeout,
+        "static ENTRY_VALUES_STRING_STORE: &str = include_str!(\"str.bin\");
+        static ENTRY_VALUES_LIST: &[Range<u32>] = &["
+    )?;
+    for range in mapout.reorder(&values_index) {
+        writeln!(codeout, "{}..{},", range.start, range.end)?;
+    }
+    writeln!(codeout, "];")?;
+
+    Ok(())
+}
+
+#[derive(Default)]
+struct StrPool<'s> {
+    pool: String,
+    map: HashMap<&'s str, u32>,
+}
+
+impl<'s> StrPool<'s> {
+    pub fn insert(&mut self, s: &'s str) -> u32 {
+        *self.map.entry(s).or_insert_with(|| {
+            let offset = self.pool.len();
+            self.pool.push_str(s);
+            let len: u8 = (self.pool.len() - offset).try_into().unwrap();
+            let offset: u32 = offset.try_into().unwrap();
+
+            if offset > (1 << 24) {
+                panic!("string too large");
+            }
+
+            offset | (u32::from(len) << 24)
+        })
+    }
+}

crates/swc_ecma_preset_env/build.rs

@@ -1,35 +1,45 @@
-use std::sync::Arc;
+use std::{ops::Range, sync::Arc};
 
 use indexmap::IndexSet;
-use once_cell::sync::Lazy;
 use preset_env_base::{
     version::{should_enable, Version},
     Versions,
 };
-use rustc_hash::{FxBuildHasher, FxHashMap};
+use rustc_hash::FxBuildHasher;
 use swc_atoms::atom;
 use swc_common::DUMMY_SP;
 use swc_ecma_ast::*;
 use swc_ecma_visit::VisitMut;
 
 use super::{compat::DATA as CORE_JS_COMPAT_DATA, data::MODULES_BY_VERSION};
+use crate::util::SwcFold;
 
-static ENTRIES: Lazy<FxHashMap<String, Vec<&'static str>>> = Lazy::new(|| {
-    serde_json::from_str::<FxHashMap<String, Vec<String>>>(include_str!(
-        "../../data/core-js-compat/entries.json"
-    ))
-    .expect("failed to parse entries.json from core js 3")
-    .into_iter()
-    .map(|(k, v)| {
-        (
-            k,
-            v.into_iter()
-                .map(|s: String| &*Box::leak(s.into_boxed_str()))
-                .collect::<Vec<_>>(),
-        )
-    })
-    .collect()
-});
+include!(concat!(env!("OUT_DIR"), "/corejs3_entries/lib.rs"));
+
+pub struct FeatureSet(Range<u32>);
+
+pub fn entries_get(name: &str) -> Option<FeatureSet> {
+    {
+        let index = ENTRY_INDEX.get(name.as_bytes())?;
+        ENTRY_VALUES_LIST.get(index).cloned().map(FeatureSet)
+    }
+}
+
+impl FeatureSet {
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = &'static str> {
+        use precomputed_map::store::AccessSeq;
+
+        self.0
+            .clone()
+            .map(|idx| EntryValuesStringId::index(idx as usize).unwrap())
+            .map(|id| {
+                let offset = id & ((1 << 24) - 1);
+                let len = id >> 24;
+
+                &ENTRY_VALUES_STRING_STORE[(offset as usize)..][..(len as usize)]
+            })
+    }
+}
 
 #[derive(Debug)]
 pub struct Entry {
@@ -68,9 +78,9 @@ impl Entry {
             return true;
         }
 
-        if let Some(features) = ENTRIES.get(src) {
+        if let Some(features) = entries_get(src) {
             self.imports.extend(features.iter().filter(|f| {
-                let feature = CORE_JS_COMPAT_DATA.get(&***f);
+                let feature = CORE_JS_COMPAT_DATA.get(*f);
 
                 if !*is_any_target {
                     if let Some(feature) = feature {
@@ -80,7 +90,7 @@ impl Entry {
                     }
                 }
 
-                if let Some(version) = MODULES_BY_VERSION.get(**f) {
+                if let Some(version) = MODULES_BY_VERSION.get(f) {
                     return version <= corejs_version;
                 }
 

crates/swc_ecma_preset_env/src/corejs3/entry.rs

@@ -687,3 +687,16 @@ impl<T> DataMapExt<T> for DataMap<T> {
         self
     }
 }
+
+pub(crate) struct SwcFold;
+
+impl precomputed_map::phf::HashOne for SwcFold {
+    fn hash_one<T: std::hash::Hash>(k: u64, v: T) -> u64 {
+        use std::hash::Hasher;
+
+        let mut hasher =
+            foldhash::fast::FoldHasher::with_seed(k, foldhash::SharedSeed::global_fixed());
+        v.hash(&mut hasher);
+        hasher.finish()
+    }
+}