refactor: inline const parser plugin (#11359)

ahabhgk · web-flow · commit 19b2442c1bd6 · 2025-08-12T19:12:54.000+08:00
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/amd/amd_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/amd/amd_plugin.rs
@@ -161,23 +161,23 @@ impl JavascriptParserPlugin for AMDParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
-    if ident == DEFINE_AMD {
+    if for_name == DEFINE_AMD {
       return Some(evaluate_to_identifier(
-        ident.to_string(),
+        for_name.to_string(),
         "define".to_string(),
         Some(true),
         start,
         end,
       ));
     }
 
-    if ident == REQUIRE_AMD {
+    if for_name == REQUIRE_AMD {
       return Some(evaluate_to_identifier(
-        ident.to_string(),
+        for_name.to_string(),
         "require".to_string(),
         Some(true),
         start,
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/api_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/api_plugin.rs
@@ -299,11 +299,11 @@ impl JavascriptParserPlugin for APIPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<eval::BasicEvaluatedExpression<'static>> {
-    if ident == WEBPACK_LAYER {
+    if for_name == WEBPACK_LAYER {
       if let Some(layer) = parser.module_layer {
         Some(eval::evaluate_to_string(layer.into(), start, end))
       } else {
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/common_js_imports_parse_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/common_js_imports_parse_plugin.rs
@@ -427,11 +427,11 @@ impl JavascriptParserPlugin for CommonJsImportsParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
-    match ident {
+    match for_name {
       expr_name::REQUIRE => Some(eval::evaluate_to_identifier(
         expr_name::REQUIRE.to_string(),
         expr_name::REQUIRE.to_string(),
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/const/mod.rs b/crates/rspack_plugin_javascript/src/parser_plugin/const/mod.rs
@@ -115,11 +115,11 @@ impl JavascriptParserPlugin for ConstPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<crate::utils::eval::BasicEvaluatedExpression<'static>> {
-    match ident {
+    match for_name {
       WEBPACK_RESOURCE_QUERY => Some(evaluate_to_string(
         parser
           .resource_data
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/parser.rs b/crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/parser.rs
@@ -82,26 +82,26 @@ impl JavascriptParserPlugin for DefineParserPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<crate::utils::eval::BasicEvaluatedExpression<'static>> {
-    if let Some(record) = self.walk_data.define_record.get(ident)
+    if let Some(record) = self.walk_data.define_record.get(for_name)
       && let Some(on_evaluate_identifier) = &record.on_evaluate_identifier
     {
       // Avoid endless recursion, for example: new DefinePlugin({ "a": "a" })
       if self.recurse.swap(true, Ordering::Acquire) {
         return None;
       }
-      self.add_value_dependency(parser, ident);
-      let evaluated = on_evaluate_identifier(record, parser, ident, start, end);
+      self.add_value_dependency(parser, for_name);
+      let evaluated = on_evaluate_identifier(record, parser, for_name, start, end);
       self.recurse.store(false, Ordering::Release);
       return evaluated;
-    } else if let Some(record) = self.walk_data.object_define_record.get(ident)
+    } else if let Some(record) = self.walk_data.object_define_record.get(for_name)
       && let Some(on_evaluate_identifier) = &record.on_evaluate_identifier
     {
-      self.add_value_dependency(parser, ident);
-      return on_evaluate_identifier(record, parser, ident, start, end);
+      self.add_value_dependency(parser, for_name);
+      return on_evaluate_identifier(record, parser, for_name, start, end);
     }
     None
   }
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/drive.rs b/crates/rspack_plugin_javascript/src/parser_plugin/drive.rs
@@ -449,12 +449,12 @@ impl JavascriptParserPlugin for JavaScriptParserPluginDrive {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
     for plugin in &self.plugins {
-      let res = plugin.evaluate_identifier(parser, ident, start, end);
+      let res = plugin.evaluate_identifier(parser, for_name, start, end);
       // `SyncBailHook`
       if res.is_some() {
         return res;
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/hot_module_replacement_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/hot_module_replacement_plugin.rs
@@ -135,11 +135,11 @@ impl JavascriptParserPlugin for ModuleHotReplacementParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<crate::utils::eval::BasicEvaluatedExpression<'static>> {
-    if ident == expr_name::MODULE_HOT {
+    if for_name == expr_name::MODULE_HOT {
       Some(eval::evaluate_to_identifier(
         expr_name::MODULE_HOT.to_string(),
         expr_name::MODULE.to_string(),
@@ -202,11 +202,11 @@ impl JavascriptParserPlugin for ImportMetaHotReplacementParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<crate::utils::eval::BasicEvaluatedExpression<'static>> {
-    if ident == expr_name::IMPORT_META_WEBPACK_HOT {
+    if for_name == expr_name::IMPORT_META_WEBPACK_HOT {
       Some(eval::evaluate_to_identifier(
         expr_name::IMPORT_META_WEBPACK_HOT.to_string(),
         expr_name::IMPORT_META.to_string(),
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/import_meta_context_dependency_parser_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/import_meta_context_dependency_parser_plugin.rs
@@ -112,11 +112,11 @@ impl JavascriptParserPlugin for ImportMetaContextDependencyParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
-    if ident == expr_name::IMPORT_META_WEBPACK_CONTEXT {
+    if for_name == expr_name::IMPORT_META_WEBPACK_CONTEXT {
       Some(eval::evaluate_to_identifier(
         expr_name::IMPORT_META_WEBPACK_CONTEXT.to_string(),
         expr_name::IMPORT_META.to_string(),
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/import_meta_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/import_meta_plugin.rs
@@ -71,13 +71,13 @@ impl JavascriptParserPlugin for ImportMetaPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<eval::BasicEvaluatedExpression<'static>> {
-    if ident == expr_name::IMPORT_META_WEBPACK {
+    if for_name == expr_name::IMPORT_META_WEBPACK {
       Some(eval::evaluate_to_number(5_f64, start, end))
-    } else if ident == expr_name::IMPORT_META_URL {
+    } else if for_name == expr_name::IMPORT_META_URL {
       Some(eval::evaluate_to_string(
         self.import_meta_url(parser),
         start,
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/inline_const.rs b/crates/rspack_plugin_javascript/src/parser_plugin/inline_const.rs
@@ -4,7 +4,7 @@ use rspack_core::{
   PrefetchExportsInfoMode, RuntimeSpec, UsedName,
 };
 use rspack_util::ryu_js;
-use swc_core::ecma::ast::{ModuleDecl, ModuleItem, Program, VarDeclKind};
+use swc_core::ecma::ast::{ModuleDecl, ModuleItem, Program, VarDecl, VarDeclKind, VarDeclarator};
 
 use super::JavascriptParserPlugin;
 use crate::{
@@ -13,7 +13,7 @@ use crate::{
     BasicEvaluatedExpression, evaluate_to_boolean, evaluate_to_null, evaluate_to_number,
     evaluate_to_string, evaluate_to_undefined,
   },
-  visitors::{JavascriptParser, Statement, TagInfoData, TopLevelScope},
+  visitors::{JavascriptParser, TagInfoData, TopLevelScope},
 };
 
 pub const INLINABLE_CONST_TAG: &str = "inlinable const";
@@ -53,20 +53,20 @@ impl JavascriptParserPlugin for InlineConstPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
-    if !parser.has_inlinable_const_decls || !matches!(parser.top_level_scope, TopLevelScope::Top) {
+    if !parser.has_inlinable_const_decls || for_name != INLINABLE_CONST_TAG {
       return None;
     }
     // Propagate inlinable constants. Help the rest const variable declarations that referencing the
     // inlinable constants to evaluate to an inlinable constants.
-    let inlinable = parser
-      .get_tag_data(ident, INLINABLE_CONST_TAG)
-      .map(InlinableConstData::downcast)
-      .map(|data| data.value)?;
-    Some(match inlinable {
+    let tag_info = parser
+      .definitions_db
+      .expect_get_tag_info(parser.current_tag_info?);
+    let data = InlinableConstData::downcast(tag_info.data.clone()?);
+    Some(match data.value {
       EvaluatedInlinableValue::Null => evaluate_to_null(start, end),
       EvaluatedInlinableValue::Undefined => evaluate_to_undefined(start, end),
       EvaluatedInlinableValue::Boolean(v) => evaluate_to_boolean(v, start, end),
@@ -75,32 +75,28 @@ impl JavascriptParserPlugin for InlineConstPlugin {
     })
   }
 
-  fn block_pre_statement(&self, parser: &mut JavascriptParser, stmt: Statement) -> Option<bool> {
+  fn pre_declarator(
+    &self,
+    parser: &mut JavascriptParser,
+    declarator: &VarDeclarator,
+    declaration: &VarDecl,
+  ) -> Option<bool> {
     if !parser.has_inlinable_const_decls || !matches!(parser.top_level_scope, TopLevelScope::Top) {
       return None;
     }
-
-    if let Statement::Var(declaration) = stmt
-      && matches!(declaration.kind, VarDeclKind::Const)
+    if matches!(declaration.kind, VarDeclKind::Const)
+      && let Some(name) = declarator.name.as_ident()
+      && let Some(init) = &declarator.init
     {
-      for declarator in &declaration.decls {
-        if let Some(name) = declarator.name.as_ident()
-          && let Some(init) = &declarator.init
-        {
-          let evaluated = parser.evaluate_expression(init);
-          if let Some(inlinable) = to_evaluated_inlinable_value(&evaluated) {
-            parser.tag_variable(
-              name.id.sym.to_string(),
-              INLINABLE_CONST_TAG,
-              Some(InlinableConstData { value: inlinable }),
-            );
-            continue;
-          }
-        }
+      let evaluated = parser.evaluate_expression(init);
+      if let Some(inlinable) = to_evaluated_inlinable_value(&evaluated) {
+        parser.tag_variable(
+          name.id.sym.to_string(),
+          INLINABLE_CONST_TAG,
+          Some(InlinableConstData { value: inlinable }),
+        );
       }
-      return None;
     }
-
     None
   }
 }
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/node_stuff_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/node_stuff_plugin.rs
@@ -166,11 +166,11 @@ impl JavascriptParserPlugin for NodeStuffPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut crate::visitors::JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<crate::utils::eval::BasicEvaluatedExpression<'static>> {
-    if ident == DIR_NAME {
+    if for_name == DIR_NAME {
       if parser
         .compiler_options
         .node
@@ -184,7 +184,7 @@ impl JavascriptParserPlugin for NodeStuffPlugin {
         start,
         end,
       ))
-    } else if ident == FILE_NAME {
+    } else if for_name == FILE_NAME {
       if parser
         .compiler_options
         .node
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/trait.rs b/crates/rspack_plugin_javascript/src/parser_plugin/trait.rs
@@ -91,7 +91,7 @@ pub trait JavascriptParserPlugin {
   fn evaluate_identifier(
     &self,
     _parser: &mut JavascriptParser,
-    _ident: &str,
+    _for_name: &str,
     _start: u32,
     _end: u32,
   ) -> Option<BasicEvaluatedExpression<'static>> {
diff --git a/crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs b/crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs
@@ -363,11 +363,6 @@ impl<'parser> JavascriptParser<'parser> {
       plugins.push(Box::new(parser_plugin::OverrideStrictPlugin));
     }
 
-    if compiler_options.optimization.inner_graph {
-      plugins.push(Box::new(parser_plugin::InnerGraphPlugin::new(
-        unresolved_mark,
-      )));
-    }
     // disabled by default for now, it's still experimental
     if javascript_options.inline_const.unwrap_or_default() {
       if !compiler_options.experiments.inline_const {
@@ -376,6 +371,11 @@ impl<'parser> JavascriptParser<'parser> {
         plugins.push(Box::new(parser_plugin::InlineConstPlugin));
       }
     }
+    if compiler_options.optimization.inner_graph {
+      plugins.push(Box::new(parser_plugin::InnerGraphPlugin::new(
+        unresolved_mark,
+      )));
+    }
 
     if !matches!(
       javascript_options
diff --git a/crates/rspack_plugin_rstest/src/parser_plugin.rs b/crates/rspack_plugin_rstest/src/parser_plugin.rs
@@ -708,18 +708,18 @@ impl JavascriptParserPlugin for RstestParserPlugin {
   fn evaluate_identifier(
     &self,
     parser: &mut JavascriptParser,
-    ident: &str,
+    for_name: &str,
     start: u32,
     end: u32,
   ) -> Option<eval::BasicEvaluatedExpression<'static>> {
     if self.import_meta_path_name {
-      if ident == IMPORT_META_DIRNAME {
+      if for_name == IMPORT_META_DIRNAME {
         return Some(eval::evaluate_to_string(
           self.process_import_meta(parser, ModulePathType::DirName),
           start,
           end,
         ));
-      } else if ident == IMPORT_META_FILENAME {
+      } else if for_name == IMPORT_META_FILENAME {
         return Some(eval::evaluate_to_string(
           self.process_import_meta(parser, ModulePathType::FileName),
           start,
