fix: amd require array (#9113)

crates/rspack_plugin_javascript/src/dependency/amd/amd_define_dependency.rs

@@ -164,7 +164,7 @@ impl Branch {
 
 #[cacheable]
 #[derive(Debug, Clone)]
-pub struct AmdDefineDependency {
+pub struct AMDDefineDependency {
   id: DependencyId,
   range: (u32, u32),
   array_range: Option<(u32, u32)>,
@@ -175,7 +175,7 @@ pub struct AmdDefineDependency {
   local_module: Option<LocalModule>,
 }
 
-impl AmdDefineDependency {
+impl AMDDefineDependency {
   pub fn new(
     range: (u32, u32),
     array_range: Option<(u32, u32)>,
@@ -201,7 +201,7 @@ impl AmdDefineDependency {
 }
 
 #[cacheable_dyn]
-impl Dependency for AmdDefineDependency {
+impl Dependency for AMDDefineDependency {
   fn id(&self) -> &DependencyId {
     &self.id
   }
@@ -219,7 +219,7 @@ impl Dependency for AmdDefineDependency {
   }
 }
 
-impl AmdDefineDependency {
+impl AMDDefineDependency {
   fn local_module_var(&self) -> Option<String> {
     self.local_module.as_ref().and_then(|m| {
       if m.is_used() {
@@ -249,7 +249,7 @@ impl AmdDefineDependency {
 }
 
 #[cacheable_dyn]
-impl DependencyTemplate for AmdDefineDependency {
+impl DependencyTemplate for AMDDefineDependency {
   fn apply(
     &self,
     source: &mut TemplateReplaceSource,
@@ -305,6 +305,6 @@ impl DependencyTemplate for AmdDefineDependency {
   }
 }
 
-impl AsModuleDependency for AmdDefineDependency {}
+impl AsModuleDependency for AMDDefineDependency {}
 
-impl AsContextDependency for AmdDefineDependency {}
+impl AsContextDependency for AMDDefineDependency {}

crates/rspack_plugin_javascript/src/dependency/amd/amd_require_array_dependency.rs

@@ -1,35 +1,33 @@
+use std::borrow::Cow;
+
 use itertools::Itertools;
-use rspack_cacheable::{cacheable, cacheable_dyn, with::AsPreset};
+use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   module_raw, AffectType, AsContextDependency, AsModuleDependency, Compilation, Dependency,
   DependencyCategory, DependencyId, DependencyTemplate, DependencyType, ModuleDependency,
   RuntimeSpec, TemplateContext, TemplateReplaceSource,
 };
-use rspack_util::atom::Atom;
 
-use super::{
-  amd_require_item_dependency::AMDRequireItemDependency,
-  local_module_dependency::LocalModuleDependency,
-};
+use super::amd_require_item_dependency::AMDRequireItemDependency;
 
 #[cacheable]
 #[derive(Debug, Clone)]
-pub enum AmdDep {
-  String(#[cacheable(with=AsPreset)] Atom),
-  LocalModuleDependency(LocalModuleDependency),
-  AMDRequireItemDependency(AMDRequireItemDependency),
+pub enum AMDRequireArrayItem {
+  String(String),
+  LocalModuleDependency { local_module_variable_name: String },
+  AMDRequireItemDependency { dep_id: DependencyId },
 }
 
 #[cacheable]
 #[derive(Debug, Clone)]
-pub struct AmdRequireArrayDependency {
+pub struct AMDRequireArrayDependency {
   id: DependencyId,
-  deps_array: Vec<AmdDep>,
+  deps_array: Vec<AMDRequireArrayItem>,
   range: (u32, u32),
 }
 
-impl AmdRequireArrayDependency {
-  pub fn new(deps_array: Vec<AmdDep>, range: (u32, u32)) -> Self {
+impl AMDRequireArrayDependency {
+  pub fn new(deps_array: Vec<AMDRequireArrayItem>, range: (u32, u32)) -> Self {
     Self {
       id: DependencyId::new(),
       deps_array,
@@ -39,7 +37,7 @@ impl AmdRequireArrayDependency {
 }
 
 #[cacheable_dyn]
-impl Dependency for AmdRequireArrayDependency {
+impl Dependency for AMDRequireArrayDependency {
   fn id(&self) -> &DependencyId {
     &self.id
   }
@@ -57,7 +55,7 @@ impl Dependency for AmdRequireArrayDependency {
   }
 }
 
-impl AmdRequireArrayDependency {
+impl AMDRequireArrayDependency {
   fn get_content(&self, code_generatable_context: &mut TemplateContext) -> String {
     format!(
       "[{}]",
@@ -69,26 +67,36 @@ impl AmdRequireArrayDependency {
     )
   }
 
-  fn content_for_dependency(
-    dep: &AmdDep,
+  fn content_for_dependency<'a>(
+    dep: &'a AMDRequireArrayItem,
     code_generatable_context: &mut TemplateContext,
-  ) -> String {
+  ) -> Cow<'a, str> {
     match dep {
-      AmdDep::String(name) => name.to_string(),
-      AmdDep::LocalModuleDependency(dep) => dep.get_variable_name(),
-      AmdDep::AMDRequireItemDependency(dep) => module_raw(
-        code_generatable_context.compilation,
-        code_generatable_context.runtime_requirements,
-        dep.id(),
-        dep.request(),
-        dep.weak(),
-      ),
+      AMDRequireArrayItem::String(name) => name.into(),
+      AMDRequireArrayItem::LocalModuleDependency {
+        local_module_variable_name,
+      } => local_module_variable_name.into(),
+      AMDRequireArrayItem::AMDRequireItemDependency { dep_id } => {
+        let mg = code_generatable_context.compilation.get_module_graph();
+        let dep = mg
+          .dependency_by_id(dep_id)
+          .and_then(|dep| dep.downcast_ref::<AMDRequireItemDependency>())
+          .expect("should have AMDRequireItemDependency");
+        module_raw(
+          code_generatable_context.compilation,
+          code_generatable_context.runtime_requirements,
+          dep_id,
+          dep.request(),
+          dep.weak(),
+        )
+        .into()
+      }
     }
   }
 }
 
 #[cacheable_dyn]
-impl DependencyTemplate for AmdRequireArrayDependency {
+impl DependencyTemplate for AMDRequireArrayDependency {
   fn apply(
     &self,
     source: &mut TemplateReplaceSource,
@@ -111,6 +119,6 @@ impl DependencyTemplate for AmdRequireArrayDependency {
   }
 }
 
-impl AsModuleDependency for AmdRequireArrayDependency {}
+impl AsModuleDependency for AMDRequireArrayDependency {}
 
-impl AsContextDependency for AmdRequireArrayDependency {}
+impl AsContextDependency for AMDRequireArrayDependency {}

crates/rspack_plugin_javascript/src/dependency/amd/amd_require_item_dependency.rs

@@ -12,12 +12,12 @@ pub struct AMDRequireItemDependency {
   id: DependencyId,
   #[cacheable(with=AsPreset)]
   request: Atom,
-  range: (u32, u32),
+  range: Option<(u32, u32)>,
   optional: bool,
 }
 
 impl AMDRequireItemDependency {
-  pub fn new(request: Atom, range: (u32, u32)) -> Self {
+  pub fn new(request: Atom, range: Option<(u32, u32)>) -> Self {
     Self {
       id: DependencyId::new(),
       request,
@@ -57,6 +57,9 @@ impl DependencyTemplate for AMDRequireItemDependency {
     source: &mut TemplateReplaceSource,
     code_generatable_context: &mut TemplateContext,
   ) {
+    let Some(range) = &self.range else {
+      return;
+    };
     // ModuleDependencyTemplateAsRequireId
     let content = module_raw(
       code_generatable_context.compilation,
@@ -65,7 +68,7 @@ impl DependencyTemplate for AMDRequireItemDependency {
       &self.request,
       self.weak(),
     );
-    source.replace(self.range.0, self.range.1, &content, None);
+    source.replace(range.0, range.1, &content, None);
   }
 
   fn dependency_id(&self) -> Option<DependencyId> {

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

@@ -1,7 +1,8 @@
 use std::borrow::Cow;
 
 use rspack_core::{
-  BuildMetaDefaultObject, BuildMetaExportsType, ConstDependency, RuntimeGlobals, SpanExt,
+  BuildMetaDefaultObject, BuildMetaExportsType, ConstDependency, Dependency, RuntimeGlobals,
+  SpanExt,
 };
 use rspack_util::atom::Atom;
 use rustc_hash::FxHashMap;
@@ -15,7 +16,8 @@ use swc_core::{
 
 use crate::{
   dependency::{
-    amd_define_dependency::AmdDefineDependency,
+    amd_define_dependency::AMDDefineDependency,
+    amd_require_array_dependency::{AMDRequireArrayDependency, AMDRequireArrayItem},
     amd_require_item_dependency::AMDRequireItemDependency,
     local_module_dependency::LocalModuleDependency,
   },
@@ -65,21 +67,17 @@ fn is_callable(expr: &Expr) -> bool {
   is_unbound_function_expression(expr) || is_bound_function_expression(expr)
 }
 
-/**
- * lookup
- *
- * define('ui/foo/bar', ['./baz', '../qux'], ...);
- * - 'ui/foo/baz'
- * - 'ui/qux'
- */
-fn resolve_mod_name(mod_name: &Option<Atom>, dep_name: &str) -> Atom {
-  if let Some(mod_name) = mod_name
-    && dep_name.starts_with('.')
+/// define('ui/foo/bar', ['./baz', '../qux'], ...);
+/// - 'ui/foo/baz'
+/// - 'ui/qux'
+fn lookup(parent: &Option<Atom>, module: &str) -> Atom {
+  if let Some(parent) = parent
+    && module.starts_with('.')
   {
-    let mut path: Vec<&str> = mod_name.split('/').collect();
+    let mut path: Vec<&str> = parent.split('/').collect();
     path.pop();
 
-    for seg in dep_name.split('.') {
+    for seg in module.split('.') {
       if seg == ".." {
         path.pop();
       } else if seg != "." {
@@ -89,7 +87,7 @@ fn resolve_mod_name(mod_name: &Option<Atom>, dep_name: &str) -> Atom {
 
     path.join("/").into()
   } else {
-    dep_name.into()
+    module.into()
   }
 }
 
@@ -140,9 +138,38 @@ impl AMDDefineDependencyParserPlugin {
         }
       }
       return Some(true);
+    } else if param.is_const_array() {
+      let mut deps: Vec<AMDRequireArrayItem> = vec![];
+      let array = param.array();
+      for (i, request) in array.iter().enumerate() {
+        if request == "require" {
+          identifiers.insert(i, REQUIRE);
+          deps.push(AMDRequireArrayItem::String(
+            RuntimeGlobals::REQUIRE.name().into(),
+          ));
+        } else if request == "exports" {
+          identifiers.insert(i, EXPORTS);
+          deps.push(AMDRequireArrayItem::String(request.into()));
+        } else if request == "module" {
+          identifiers.insert(i, MODULE);
+          deps.push(AMDRequireArrayItem::String(request.into()));
+        } else if let Some(local_module) = parser.get_local_module_mut(request) {
+          local_module.flag_used();
+          deps.push(AMDRequireArrayItem::LocalModuleDependency {
+            local_module_variable_name: local_module.variable_name(),
+          })
+        } else {
+          let mut dep = AMDRequireItemDependency::new(request.as_str().into(), None);
+          dep.set_optional(parser.in_try);
+          deps.push(AMDRequireArrayItem::AMDRequireItemDependency { dep_id: *dep.id() });
+          parser.dependencies.push(Box::new(dep));
+        }
+      }
+      let range = param.range();
+      let dep = AMDRequireArrayDependency::new(deps, (range.0, range.1 - 1));
+      parser.presentational_dependencies.push(Box::new(dep));
+      return Some(true);
     }
-    // currently, there is no ConstArray in rspack
-    // TODO: check if `param` is a const string array
     None
   }
 
@@ -193,7 +220,7 @@ impl AMDDefineDependencyParserPlugin {
           Some(RuntimeGlobals::MODULE),
         ))
       } else if let Some(local_module) =
-        parser.get_local_module_mut(&resolve_mod_name(named_module, param_str))
+        parser.get_local_module_mut(&lookup(named_module, param_str))
       {
         local_module.flag_used();
         let dep = Box::new(LocalModuleDependency::new(
@@ -206,7 +233,7 @@ impl AMDDefineDependencyParserPlugin {
       } else {
         let mut dep = Box::new(AMDRequireItemDependency::new(
           Atom::new(param_str.as_str()),
-          range,
+          Some(range),
         ));
         dep.set_optional(parser.in_try);
         parser.dependencies.push(dep);
@@ -542,7 +569,7 @@ impl AMDDefineDependencyParserPlugin {
       .as_ref()
       .map(|name| parser.add_local_module(name.as_str()));
 
-    let dep = Box::new(AmdDefineDependency::new(
+    let dep = Box::new(AMDDefineDependency::new(
       (call_expr.span.real_lo(), call_expr.span.real_hi()),
       array.map(|expr| span_to_range(expr.span())),
       func.map(|expr| span_to_range(expr.span())),
@@ -578,7 +605,7 @@ impl JavascriptParserPlugin for AMDDefineDependencyParserPlugin {
    */
   fn finish(&self, parser: &mut JavascriptParser) -> Option<bool> {
     for dep in parser.presentational_dependencies.iter_mut() {
-      if let Some(define_dep) = dep.as_any_mut().downcast_mut::<AmdDefineDependency>()
+      if let Some(define_dep) = dep.as_any_mut().downcast_mut::<AMDDefineDependency>()
         && let Some(local_module) = define_dep.get_local_module_mut()
         && parser
           .local_modules