refactor(compiler): improve id generating

Author: Wenjie Xia

compiler/src/jsx.rs

@@ -53,7 +53,13 @@ impl AlephJsxFold {
         let mut hasher = Sha1::new();
         hasher.update(resolver.specifier.clone());
         hasher.update(self.inline_style_idx.to_string());
-        ident.push_str(base64::encode(hasher.finalize()).as_str());
+        ident.push_str(
+            base64::encode(hasher.finalize())
+                .replace("/", "")
+                .replace("+", "")
+                .as_str()
+                .trim_end_matches("="),
+        );
         ident
     }
 
@@ -69,7 +75,7 @@ impl AlephJsxFold {
                 match name {
                     "head" | "script" => {
                         let mut resolver = self.resolver.borrow_mut();
-                        resolver.builtin_jsx_tags.insert(name.into());
+                        resolver.used_builtin_jsx_tags.insert(name.into());
                         el.name = JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                     }
 
@@ -97,7 +103,7 @@ impl AlephJsxFold {
                         }
 
                         if should_replace {
-                            resolver.builtin_jsx_tags.insert(name.into());
+                            resolver.used_builtin_jsx_tags.insert(name.into());
                             el.name = JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                         }
                     }
@@ -214,7 +220,7 @@ impl AlephJsxFold {
                             }
 
                             if name.eq("link") {
-                                resolver.builtin_jsx_tags.insert(name.into());
+                                resolver.used_builtin_jsx_tags.insert(name.into());
                                 el.name =
                                     JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                             }
@@ -268,7 +274,7 @@ impl AlephJsxFold {
                             is_dynamic: false,
                             rel: None,
                         });
-                        resolver.builtin_jsx_tags.insert(name.into());
+                        resolver.used_builtin_jsx_tags.insert(name.into());
                         el.name = JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                         inline_style = Some((type_prop_value, id.into()));
                     }
@@ -419,7 +425,7 @@ impl Fold for AlephJsxBuiltinModuleResolveFold {
         let mut items = Vec::<ModuleItem>::new();
         let mut resolver = self.resolver.borrow_mut();
 
-        for mut name in resolver.builtin_jsx_tags.clone() {
+        for mut name in resolver.used_builtin_jsx_tags.clone() {
             if name.eq("a") {
                 name = "anchor".to_owned()
             }

compiler/src/resolve.rs

@@ -17,7 +17,7 @@ use std::{
   rc::Rc,
   str::FromStr,
 };
-use swc_common::DUMMY_SP;
+use swc_common::{SourceMap, Span, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_utils::quote_ident;
 use swc_ecma_visit::{noop_fold_type, Fold, FoldWith};
@@ -53,14 +53,13 @@ pub struct InlineStyle {
 }
 
 /// A Resolver to resolve aleph.js import/export URL.
-#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Resolver {
   /// The text specifier associated with the import/export statement.
   pub specifier: String,
   /// A flag indicating if the specifier is remote url or not.
   pub specifier_is_remote: bool,
   ///  builtin jsx tags like `a`, `link`, `head`, etc
-  pub builtin_jsx_tags: IndexSet<String>,
+  pub used_builtin_jsx_tags: IndexSet<String>,
   /// dependency graph
   pub dep_graph: Vec<DependencyDescriptor>,
   /// inline styles
@@ -88,7 +87,7 @@ impl Resolver {
     Resolver {
       specifier: specifier.into(),
       specifier_is_remote: is_remote_url(specifier),
-      builtin_jsx_tags: IndexSet::new(),
+      used_builtin_jsx_tags: IndexSet::new(),
       dep_graph: Vec::new(),
       inline_styles: HashMap::new(),
       import_map: ImportMap::from_hashmap(import_map),
@@ -360,27 +359,38 @@ impl Resolver {
   }
 }
 
-pub fn aleph_resolve_fold(resolver: Rc<RefCell<Resolver>>) -> impl Fold {
+pub fn aleph_resolve_fold(resolver: Rc<RefCell<Resolver>>, source: Rc<SourceMap>) -> impl Fold {
   AlephResolveFold {
     deno_hooks_idx: 0,
     resolver,
+    source,
   }
 }
 
 pub struct AlephResolveFold {
   deno_hooks_idx: i32,
   resolver: Rc<RefCell<Resolver>>,
+  source: Rc<SourceMap>,
 }
 
 impl AlephResolveFold {
-  fn new_use_deno_hook_ident(&mut self) -> String {
+  fn new_use_deno_hook_ident(&mut self, callback_span: &Span) -> String {
     let resolver = self.resolver.borrow_mut();
     self.deno_hooks_idx = self.deno_hooks_idx + 1;
     let mut ident: String = "useDeno-".to_owned();
     let mut hasher = Sha1::new();
+    let callback_code = self.source.span_to_snippet(callback_span.clone()).unwrap();
     hasher.update(resolver.specifier.clone());
     hasher.update(self.deno_hooks_idx.to_string());
-    ident.push_str(base64::encode(hasher.finalize()).as_str());
+    hasher.update(callback_code.clone());
+    println!("---{}---", callback_code);
+    ident.push_str(
+      base64::encode(hasher.finalize())
+        .replace("/", "")
+        .replace("+", "")
+        .as_str()
+        .trim_end_matches("="),
+    );
     ident
   }
 }
@@ -661,17 +671,20 @@ impl Fold for AlephResolveFold {
         )))),
       }];
     } else if is_call_expr_by_name(&call, "useDeno") {
-      let has_callback = match call.args.first() {
+      let callback_span = match call.args.first() {
         Some(ExprOrSpread { expr, .. }) => match expr.as_ref() {
-          Expr::Fn(_) => true,
-          Expr::Arrow(_) => true,
-          _ => false,
+          Expr::Fn(FnExpr {
+            function: Function { span, .. },
+            ..
+          }) => Some(span),
+          Expr::Arrow(ArrowExpr { span, .. }) => Some(span),
+          _ => None,
         },
-        _ => false,
+        _ => None,
       };
-      if has_callback {
+      if let Some(span) = callback_span {
         let bundle_mode = self.resolver.borrow().bundle_mode;
-        let id = self.new_use_deno_hook_ident();
+        let id = self.new_use_deno_hook_ident(span);
         if bundle_mode {
           call.args[0] = ExprOrSpread {
             spread: None,

compiler/src/swc.rs

@@ -145,7 +145,7 @@ impl ParsedModule {
       );
       let root_mark = Mark::fresh(Mark::root());
       let mut passes = chain!(
-        aleph_resolve_fold(resolver.clone()),
+        aleph_resolve_fold(resolver.clone(), self.source_map.clone()),
         Optional::new(aleph_jsx_fold, is_jsx),
         Optional::new(aleph_jsx_builtin_resolve_fold, is_jsx),
         Optional::new(jsx_link_fixer_fold(resolver.clone()), is_jsx && bundle_mode),
@@ -368,7 +368,9 @@ mod tests {
     let source = r#"
       export default function Index() {
         const verison = useDeno(() => Deno.version)
-        const verison = useDeno(async () => await readJson("data.json"), 1000)
+        const verison = useDeno(async function() {
+          return await readJson("./data.json")
+        }, 1000)
         return (
           <>
             <p>Deno v{version.deno}</p>
@@ -382,12 +384,24 @@ mod tests {
     let mut hasher = Sha1::new();
     hasher.update(specifer.clone());
     hasher.update("1");
-    let id_1 = base64::encode(hasher.finalize());
+    hasher.update("() => Deno.version");
+    let id_1 = base64::encode(hasher.finalize())
+      .replace("/", "")
+      .replace("+", "");
+    let id_1 = id_1.trim_end_matches("=");
 
     let mut hasher = Sha1::new();
     hasher.update(specifer.clone());
     hasher.update("2");
-    let id_2 = base64::encode(hasher.finalize());
+    hasher.update(
+      r#"async function() {
+          return await readJson("./data.json")
+        }"#,
+    );
+    let id_2 = base64::encode(hasher.finalize())
+      .replace("/", "")
+      .replace("+", "");
+    let id_2 = id_2.trim_end_matches("=");
 
     for _ in 0..3 {
       let (code, _) = t(specifer, source, false);