refactor: use Atom for parser variable name (#11483)

Author: ahabhgk

crates/rspack_plugin_javascript/src/parser_plugin/amd/amd_define_dependency_parser_plugin.rs

@@ -117,7 +117,7 @@ impl AMDDefineDependencyParserPlugin {
     parser: &mut JavascriptParser,
     call_expr: &CallExpr,
     param: &BasicEvaluatedExpression,
-    identifiers: &mut FxHashMap<usize, &'static str>, // param index => "require" | "module" | "exports"
+    identifiers: &mut FxHashMap<usize, Atom>, // param index => "require" | "module" | "exports"
     named_module: &Option<Atom>,
   ) -> Option<bool> {
     if param.is_array() {
@@ -126,7 +126,7 @@ impl AMDDefineDependencyParserPlugin {
         if item.is_string() {
           let item = item.string();
           if let Some(i) = RESERVED_NAMES.iter().position(|s| s == item) {
-            identifiers.insert(idx, RESERVED_NAMES[i]);
+            identifiers.insert(idx, RESERVED_NAMES[i].into());
           }
         }
         let result = self.process_item(parser, call_expr, item, named_module);
@@ -140,15 +140,15 @@ impl AMDDefineDependencyParserPlugin {
       let array = param.array();
       for (i, request) in array.iter().enumerate() {
         if request == "require" {
-          identifiers.insert(i, REQUIRE);
+          identifiers.insert(i, REQUIRE.into());
           deps.push(AMDRequireArrayItem::String(
             RuntimeGlobals::REQUIRE.name().into(),
           ));
         } else if request == "exports" {
-          identifiers.insert(i, EXPORTS);
+          identifiers.insert(i, EXPORTS.into());
           deps.push(AMDRequireArrayItem::String(request.into()));
         } else if request == "module" {
-          identifiers.insert(i, MODULE);
+          identifiers.insert(i, MODULE.into());
           deps.push(AMDRequireArrayItem::String(request.into()));
         } else if let Some(local_module) = parser.get_local_module_mut(request) {
           local_module.flag_used();
@@ -464,8 +464,8 @@ impl AMDDefineDependencyParserPlugin {
           }
           let idx = i - fn_params_offset;
           i += 1;
-          if let Some(&name) = identifiers.get(&idx) {
-            fn_renames.insert(get_ident_name(param), name);
+          if let Some(name) = identifiers.get(&idx) {
+            fn_renames.insert(get_ident_name(param), name.clone());
             return false;
           }
           true
@@ -480,7 +480,7 @@ impl AMDDefineDependencyParserPlugin {
         let idx = i - fn_params_offset;
         i += 1;
         if idx < RESERVED_NAMES.len() {
-          fn_renames.insert(get_ident_name(param), RESERVED_NAMES[idx]);
+          fn_renames.insert(get_ident_name(param), RESERVED_NAMES[idx].into());
           return false;
         }
         true
@@ -493,12 +493,12 @@ impl AMDDefineDependencyParserPlugin {
         true,
         fn_params.expect("fn_params should not be None").into_iter(),
         |parser| {
-          for (name, &rename_identifier) in fn_renames.iter() {
+          for (name, rename_identifier) in fn_renames.iter() {
             let variable = parser
               .get_variable_info(rename_identifier)
               .map(|info| ExportedVariableInfo::VariableInfo(info.id()))
-              .unwrap_or(ExportedVariableInfo::Name(rename_identifier.to_string()));
-            parser.set_variable(name.to_string(), variable);
+              .unwrap_or(ExportedVariableInfo::Name(rename_identifier.clone()));
+            parser.set_variable(name.clone(), variable);
           }
 
           parser.in_try = in_try;
@@ -549,12 +549,12 @@ impl AMDDefineDependencyParserPlugin {
                   .is_some_and(|ident| !RESERVED_NAMES.contains(&ident.sym.as_str()))
               }),
             |parser| {
-              for (name, &rename_identifier) in fn_renames.iter() {
+              for (name, rename_identifier) in fn_renames.iter() {
                 let variable = parser
                   .get_variable_info(rename_identifier)
                   .map(|info| ExportedVariableInfo::VariableInfo(info.id()))
-                  .unwrap_or(ExportedVariableInfo::Name(rename_identifier.to_string()));
-                parser.set_variable(name.to_string(), variable);
+                  .unwrap_or(ExportedVariableInfo::Name(rename_identifier.clone()));
+                parser.set_variable(name.clone(), variable);
               }
 
               parser.in_try = in_try;

crates/rspack_plugin_javascript/src/parser_plugin/amd/amd_plugin.rs

@@ -167,8 +167,8 @@ impl JavascriptParserPlugin for AMDParserPlugin {
   ) -> Option<BasicEvaluatedExpression<'static>> {
     if for_name == DEFINE_AMD {
       return Some(evaluate_to_identifier(
-        for_name.to_string(),
-        "define".to_string(),
+        for_name.into(),
+        "define".into(),
         Some(true),
         start,
         end,
@@ -177,8 +177,8 @@ impl JavascriptParserPlugin for AMDParserPlugin {
 
     if for_name == REQUIRE_AMD {
       return Some(evaluate_to_identifier(
-        for_name.to_string(),
-        "require".to_string(),
+        for_name.into(),
+        "require".into(),
         Some(true),
         start,
         end,

crates/rspack_plugin_javascript/src/parser_plugin/api_plugin.rs

@@ -1,16 +1,45 @@
 use rspack_core::{ConstDependency, RuntimeGlobals, RuntimeRequirementsDependency, SpanExt};
+use rspack_error::{Severity, TraceableError};
 use swc_core::{
-  common::Spanned,
-  ecma::ast::{CallExpr, Callee, Expr, Ident, UnaryExpr},
+  common::{SourceFile, Span, Spanned},
+  ecma::ast::{CallExpr, Ident, UnaryExpr},
 };
 
 use crate::{
   dependency::ModuleArgumentDependency,
   parser_plugin::JavascriptParserPlugin,
   utils::eval::{self, BasicEvaluatedExpression},
-  visitors::{JavascriptParser, expr_matcher, expression_not_supported, extract_member_root},
+  visitors::{JavascriptParser, create_traceable_error},
 };
 
+fn expression_not_supported(
+  file: &SourceFile,
+  name: &str,
+  is_call: bool,
+  expr_span: Span,
+) -> (Box<TraceableError>, Box<ConstDependency>) {
+  (
+    Box::new(
+      create_traceable_error(
+        "Unsupported feature".into(),
+        format!(
+          "{name}{} is not supported by Rspack.",
+          if is_call { "()" } else { "" }
+        ),
+        file,
+        expr_span.into(),
+      )
+      .with_severity(Severity::Warn)
+      .with_hide_stack(Some(true)),
+    ),
+    Box::new(ConstDependency::new(
+      expr_span.into(),
+      "(void 0)".into(),
+      None,
+    )),
+  )
+}
+
 const WEBPACK_HASH: &str = "__webpack_hash__";
 const WEBPACK_LAYER: &str = "__webpack_layer__";
 const WEBPACK_PUBLIC_PATH: &str = "__webpack_public_path__";
@@ -318,54 +347,42 @@ impl JavascriptParserPlugin for APIPlugin {
     &self,
     parser: &mut JavascriptParser,
     member_expr: &swc_core::ecma::ast::MemberExpr,
-    _name: &str,
+    for_name: &str,
   ) -> Option<bool> {
-    macro_rules! not_supported_expr {
-      ($check: ident, $expr: ident, $name: literal) => {
-        if expr_matcher::$check($expr) {
-          let (warning, dep) = expression_not_supported(&parser.source_file, $name, $expr);
-          parser.warning_diagnostics.push(warning);
-          parser.presentational_dependencies.push(dep);
-          return Some(true);
-        }
-      };
-    }
-
-    let expr = &swc_core::ecma::ast::Expr::Member(member_expr.to_owned());
-
-    if let Some(root) = extract_member_root(expr)
-      && let s = root.sym.as_str()
-      && parser.is_unresolved_ident(s)
+    if for_name == "require.extensions"
+      || for_name == "require.config"
+      || for_name == "require.version"
+      || for_name == "require.include"
+      || for_name == "require.onError"
+      || for_name == "require.main.require"
+      || for_name == "module.parent.require"
     {
-      if s == "require" {
-        not_supported_expr!(is_require_extensions, expr, "require.extensions");
-        not_supported_expr!(is_require_config, expr, "require.config");
-        not_supported_expr!(is_require_version, expr, "require.version");
-        not_supported_expr!(is_require_include, expr, "require.include");
-        not_supported_expr!(is_require_onerror, expr, "require.onError");
-        not_supported_expr!(is_require_main_require, expr, "require.main.require");
-      } else if s == "module" {
-        not_supported_expr!(is_module_parent_require, expr, "module.parent.require");
-      }
+      let (warning, dep) =
+        expression_not_supported(parser.source_file, for_name, false, member_expr.span());
+      parser.warning_diagnostics.push(warning);
+      parser.presentational_dependencies.push(dep);
+      return Some(true);
     }
 
-    if expr_matcher::is_require_cache(expr) {
+    if for_name == "require.cache" {
       parser
         .presentational_dependencies
         .push(Box::new(ConstDependency::new(
-          expr.span().into(),
+          member_expr.span().into(),
           RuntimeGlobals::MODULE_CACHE.name().into(),
           Some(RuntimeGlobals::MODULE_CACHE),
         )));
-      Some(true)
-    } else if expr_matcher::is_require_main(expr) {
+      return Some(true);
+    }
+
+    if for_name == "require.main" {
       let mut runtime_requirements = RuntimeGlobals::default();
       runtime_requirements.insert(RuntimeGlobals::MODULE_CACHE);
       runtime_requirements.insert(RuntimeGlobals::ENTRY_MODULE_ID);
       parser
         .presentational_dependencies
         .push(Box::new(ConstDependency::new(
-          expr.span().into(),
+          member_expr.span().into(),
           format!(
             "{}[{}]",
             RuntimeGlobals::MODULE_CACHE,
@@ -374,8 +391,10 @@ impl JavascriptParserPlugin for APIPlugin {
           .into(),
           Some(runtime_requirements),
         )));
-      Some(true)
-    } else if expr_matcher::is_webpack_module_id(expr) {
+      return Some(true);
+    }
+
+    if for_name == "__webpack_module__.id" {
       parser
         .presentational_dependencies
         .push(Box::new(RuntimeRequirementsDependency::new(
@@ -385,51 +404,32 @@ impl JavascriptParserPlugin for APIPlugin {
         .presentational_dependencies
         .push(Box::new(ModuleArgumentDependency::new(
           Some("id".into()),
-          expr.span().into(),
+          member_expr.span().into(),
           Some(parser.source_map.clone()),
         )));
-      Some(true)
-    } else {
-      None
-    }
-  }
-
-  fn call(&self, parser: &mut JavascriptParser, call_expr: &CallExpr, _name: &str) -> Option<bool> {
-    macro_rules! not_supported_call {
-      ($check: ident, $name: literal) => {
-        if let Callee::Expr(expr_box) = &call_expr.callee
-          && let Expr::Member(expr) = &**expr_box
-          && expr_matcher::$check(&Expr::Member(expr.to_owned()))
-        {
-          let (warning, dep) = expression_not_supported(
-            &parser.source_file,
-            $name,
-            &Expr::Call(call_expr.to_owned()),
-          );
-          parser.warning_diagnostics.push(warning);
-          parser.presentational_dependencies.push(dep);
-          return Some(true);
-        }
-      };
+      return Some(true);
     }
 
-    let root = call_expr
-      .callee
-      .as_expr()
-      .and_then(|expr| extract_member_root(expr));
+    None
+  }
 
-    if let Some(root) = root
-      && let s = root.sym.as_str()
-      && parser.is_unresolved_ident(s)
+  fn call(
+    &self,
+    parser: &mut JavascriptParser,
+    call_expr: &CallExpr,
+    for_name: &str,
+  ) -> Option<bool> {
+    if for_name == "require.config"
+      || for_name == "require.include"
+      || for_name == "require.onError"
+      || for_name == "require.main.require"
+      || for_name == "module.parent.require"
     {
-      if s == "require" {
-        not_supported_call!(is_require_config, "require.config()");
-        not_supported_call!(is_require_include, "require.include()");
-        not_supported_call!(is_require_onerror, "require.onError()");
-        not_supported_call!(is_require_main_require, "require.main.require()");
-      } else if s == "module" {
-        not_supported_call!(is_module_parent_require, "module.parent.require()");
-      }
+      let (warning, dep) =
+        expression_not_supported(parser.source_file, for_name, true, call_expr.span());
+      parser.warning_diagnostics.push(warning);
+      parser.presentational_dependencies.push(dep);
+      return Some(true);
     }
 
     None

crates/rspack_plugin_javascript/src/parser_plugin/common_js_exports_parse_plugin.rs

@@ -140,13 +140,13 @@ impl JavascriptParser<'_> {
   }
 
   fn is_module_ident(&mut self, ident: &Ident) -> bool {
-    ident.sym == MODULE_NAME && self.is_unresolved_ident(MODULE_NAME)
+    ident.sym == MODULE_NAME && !self.is_variable_defined(&MODULE_NAME.into())
   }
 
   fn is_exports_ident<E: ExprLike>(&mut self, expr: &E) -> bool {
-    expr
-      .as_ident()
-      .is_some_and(|ident| ident.sym == EXPORTS_NAME && self.is_unresolved_ident(EXPORTS_NAME))
+    expr.as_ident().is_some_and(|ident| {
+      ident.sym == EXPORTS_NAME && !self.is_variable_defined(&EXPORTS_NAME.into())
+    })
   }
 
   fn is_exports_expr<E: ExprLike>(&mut self, expr: &E) -> bool {
@@ -243,7 +243,7 @@ impl JavascriptParser<'_> {
       .map(|expr| {
         if matches!(
           &**expr,
-          Expr::Ident(ident) if &ident.sym == "require" && self.is_unresolved_ident("require")
+          Expr::Ident(ident) if &ident.sym == "require" && !self.is_variable_defined(&ident.sym)
         ) {
           return true;
         }