fmt

Author: quininer

crates/swc_ecma_preset_env/build.rs

@@ -1,7 +1,10 @@
-use std::fs;
-use std::io::{ self, Write };
-use std::path::Path;
-use std::collections::{ HashMap, BTreeMap };
+use std::{
+    collections::{BTreeMap, HashMap},
+    fs,
+    io::{self, Write},
+    path::Path,
+};
+
 use anyhow::Context;
 
 fn main() -> anyhow::Result<()> {
@@ -10,21 +13,20 @@ fn main() -> anyhow::Result<()> {
 
 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 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();
@@ -43,47 +45,46 @@ fn es_preset_env_corejs3_entry() -> anyhow::Result<()> {
     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());
+            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
-        })
+        .set_next_seed(|seed, c| seed + c)
         .build(&keys)?;
 
-    if let Some(seed) = mapout.seed() {
-        if seed != SEED {
-            println!("cargo::warning=The seed has changed, please update the seed to {} for faster builds", seed);
-        }
+    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::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")
+        out_dir.join("u8.bin"),
     );
     let mut u32seq = precomputed_map::builder::U32SeqWriter::new(
         "PrecomputedU32Seq".into(),
-        out_dir.join("u32.bin")
+        out_dir.join("u32.bin"),
     );
-    
+
     let mut builder = precomputed_map::builder::CodeBuilder::new(
         "Corejs3Entries".into(),
         "SwcFold".into(),
         &mut u8seq,
-        &mut u32seq
+        &mut u32seq,
     );
 
     let k = builder.create_bytes_position_seq("EntryKeys".into(), mapout.reorder(&keys))?;
@@ -97,7 +98,8 @@ fn es_preset_env_corejs3_entry() -> anyhow::Result<()> {
 
     fs::write(out_dir.join("str.bin"), strpool.pool.as_bytes())?;
 
-    writeln!(codeout,
+    writeln!(
+        codeout,
         "static ENTRY_VALUES_STRING_STORE: &str = include_str!(\"str.bin\");
         static ENTRY_VALUES_LIST: &[Range<u32>] = &["
     )?;
@@ -119,7 +121,7 @@ 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);
+            self.pool.push_str(s);
             let len: u8 = (self.pool.len() - offset).try_into().unwrap();
             let offset: u32 = offset.try_into().unwrap();
 

crates/swc_ecma_preset_env/src/corejs3/entry.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{ops::Range, sync::Arc};
 
 use indexmap::IndexSet;
 use preset_env_base::{
@@ -10,27 +10,25 @@ use swc_atoms::atom;
 use swc_common::DUMMY_SP;
 use swc_ecma_ast::*;
 use swc_ecma_visit::VisitMut;
-use std::ops::Range;
-use crate::util::SwcFold;
 
 use super::{compat::DATA as CORE_JS_COMPAT_DATA, data::MODULES_BY_VERSION};
+use crate::util::SwcFold;
 
 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)
-}}
+
+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())

crates/swc_ecma_preset_env/src/util.rs

@@ -695,8 +695,9 @@ pub 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());
+
+        let mut hasher =
+            foldhash::fast::FoldHasher::with_seed(k, foldhash::SharedSeed::global_fixed());
         // let mut hasher = rustc_hash::FxHasher::with_seed(k as usize);
         v.hash(&mut hasher);
         hasher.finish()