refactor: import context dependency param evaluate (#6321)

crates/rspack_plugin_javascript/src/dependency/context/import_context_dependency.rs

@@ -1,6 +1,6 @@
-use rspack_core::{module_raw, parse_resource, AsModuleDependency, ContextDependency};
-use rspack_core::{normalize_context, DependencyCategory, DependencyId, DependencyTemplate};
+use rspack_core::{module_raw, AsModuleDependency, ContextDependency};
 use rspack_core::{ContextOptions, Dependency, TemplateReplaceSource};
+use rspack_core::{DependencyCategory, DependencyId, DependencyTemplate};
 use rspack_core::{DependencyType, ErrorSpan, TemplateContext};
 
 use super::create_resource_identifier_for_context_dependency;
@@ -113,34 +113,10 @@ impl DependencyTemplate for ImportContextDependency {
       return;
     }
 
-    source.replace(self.callee_start, self.callee_end, &expr, None);
-
-    if !self.replaces.is_empty() {
-      for (content, start, end) in &self.replaces {
-        source.replace(*start, *end, content, None);
-      }
-    } else {
-      let context = normalize_context(&self.options.context);
-      let query = parse_resource(&self.options.request).and_then(|data| data.query);
-      if !context.is_empty() || query.is_some() {
-        source.insert(self.callee_end, "(", None);
-        if !context.is_empty() {
-          source.insert(
-            self.args_end,
-            format!(".replace('{context}', './')").as_str(),
-            None,
-          );
-        }
-        if let Some(query) = query {
-          source.insert(
-            self.args_end,
-            format!(".replace('{query}', '')").as_str(),
-            None,
-          );
-        }
-        source.insert(self.args_end, ")", None);
-      }
+    for (content, start, end) in &self.replaces {
+      source.replace(*start, *end - 1, content, None);
     }
+    source.replace(self.callee_start, self.callee_end, &expr, None);
   }
 
   fn dependency_id(&self) -> Option<DependencyId> {

crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs

@@ -5,12 +5,11 @@ use rspack_core::{
 use rspack_core::{ChunkGroupOptions, ContextMode};
 use rspack_core::{ContextNameSpaceObject, ContextOptions, DependencyCategory, SpanExt};
 use swc_core::common::Spanned;
-use swc_core::ecma::ast::{CallExpr, Callee, Expr, Lit};
-use swc_core::ecma::atoms::Atom;
+use swc_core::ecma::ast::{CallExpr, Callee};
 
 use super::JavascriptParserPlugin;
 use crate::dependency::{ImportContextDependency, ImportDependency, ImportEagerDependency};
-use crate::visitors::{parse_order_string, scanner_context_module, ContextModuleScanResult};
+use crate::visitors::{create_context_dependency, parse_order_string, ContextModuleScanResult};
 use crate::webpack_comment::try_extract_webpack_magic_comment;
 
 pub struct ImportParserPlugin;
@@ -45,203 +44,134 @@ impl JavascriptParserPlugin for ImportParserPlugin {
       .map(|o| o.dynamic_import_prefetch)
       .and_then(|o| o.get_order());
 
-    match dyn_imported.expr.as_ref() {
-      Expr::Lit(Lit::Str(imported)) => {
-        let magic_comment_options = try_extract_webpack_magic_comment(
-          parser.source_file,
-          &parser.comments,
-          node.span,
-          imported.span,
-          &mut parser.warning_diagnostics,
-        );
-        if magic_comment_options
-          .get_webpack_ignore()
-          .unwrap_or_default()
-        {
-          return None;
-        }
-        let mode = magic_comment_options
-          .get_webpack_mode()
-          .map(|x| DynamicImportMode::from(x.as_str()));
-        let chunk_name = magic_comment_options
-          .get_webpack_chunk_name()
-          .map(|x| x.to_owned());
-        let chunk_prefetch = magic_comment_options
-          .get_webpack_prefetch()
-          .and_then(|x| parse_order_string(x.as_str()));
-        let chunk_preload = magic_comment_options
-          .get_webpack_preload()
-          .and_then(|x| parse_order_string(x.as_str()));
-        let span = ErrorSpan::from(node.span);
-        if matches!(
-          mode.unwrap_or(dynamic_import_mode),
-          DynamicImportMode::Eager
-        ) {
-          let dep = ImportEagerDependency::new(
-            node.span.real_lo(),
-            node.span.real_hi(),
-            imported.value.clone(),
-            Some(span),
-            // TODO scan dynamic import referenced exports
-            None,
-          );
-          parser.dependencies.push(Box::new(dep));
-          return Some(true);
-        }
-        let dep = Box::new(ImportDependency::new(
+    let magic_comment_options = try_extract_webpack_magic_comment(
+      parser.source_file,
+      &parser.comments,
+      node.span,
+      dyn_imported.expr.span(),
+      &mut parser.warning_diagnostics,
+    );
+    if magic_comment_options
+      .get_webpack_ignore()
+      .unwrap_or_default()
+    {
+      return None;
+    }
+
+    let mode = magic_comment_options
+      .get_webpack_mode()
+      .map(|x| DynamicImportMode::from(x.as_str()));
+    let chunk_name = magic_comment_options
+      .get_webpack_chunk_name()
+      .map(|x| x.to_owned());
+    let chunk_prefetch = magic_comment_options
+      .get_webpack_prefetch()
+      .and_then(|x| parse_order_string(x.as_str()));
+    let chunk_preload = magic_comment_options
+      .get_webpack_preload()
+      .and_then(|x| parse_order_string(x.as_str()));
+
+    let param = parser.evaluate_expression(dyn_imported.expr.as_ref());
+
+    if param.is_string() {
+      let span = ErrorSpan::from(node.span);
+      if matches!(
+        mode.unwrap_or(dynamic_import_mode),
+        DynamicImportMode::Eager
+      ) {
+        let dep = ImportEagerDependency::new(
           node.span.real_lo(),
           node.span.real_hi(),
-          imported.value.clone(),
+          param.string().as_str().into(),
           Some(span),
           // TODO scan dynamic import referenced exports
           None,
-        ));
-        let mut block = AsyncDependenciesBlock::new(
-          *parser.module_identifier,
-          Some(DependencyLocation::new(span.start, span.end)),
-          None,
-          vec![dep],
         );
-        block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-          chunk_name,
-          chunk_preload.or(dynamic_import_preload),
-          chunk_prefetch.or(dynamic_import_prefetch),
-        )));
-        parser.blocks.push(block);
-        Some(true)
+        parser.dependencies.push(Box::new(dep));
+        return Some(true);
       }
-      Expr::Tpl(tpl) if tpl.quasis.len() == 1 => {
-        let magic_comment_options = try_extract_webpack_magic_comment(
-          parser.source_file,
-          &parser.comments,
-          node.span,
-          tpl.span,
-          &mut parser.warning_diagnostics,
-        );
-        let mode = magic_comment_options
-          .get_webpack_mode()
-          .map(|x| DynamicImportMode::from(x.as_str()));
-        let chunk_name = magic_comment_options
-          .get_webpack_chunk_name()
-          .map(|x| x.to_owned());
-        let chunk_prefetch = magic_comment_options
-          .get_webpack_prefetch()
-          .and_then(|x| parse_order_string(x.as_str()));
-        let chunk_preload = magic_comment_options
-          .get_webpack_preload()
-          .and_then(|x| parse_order_string(x.as_str()));
-        let request = Atom::from(
-          tpl
-            .quasis
-            .first()
-            .expect("should have one quasis")
-            .raw
-            .to_string(),
-        );
-        let span = ErrorSpan::from(node.span);
-        if matches!(
-          mode.unwrap_or(dynamic_import_mode),
-          DynamicImportMode::Eager
-        ) {
-          let dep = ImportEagerDependency::new(
-            node.span.real_lo(),
-            node.span.real_hi(),
-            request,
-            Some(span),
-            // TODO scan dynamic import referenced exports
-            None,
-          );
-          parser.dependencies.push(Box::new(dep));
-          return Some(true);
-        }
-        let dep = Box::new(ImportDependency::new(
-          node.span.real_lo(),
+      let dep = Box::new(ImportDependency::new(
+        node.span.real_lo(),
+        node.span.real_hi(),
+        param.string().as_str().into(),
+        Some(span),
+        // TODO scan dynamic import referenced exports
+        None,
+      ));
+      let mut block = AsyncDependenciesBlock::new(
+        *parser.module_identifier,
+        Some(DependencyLocation::new(span.start, span.end)),
+        None,
+        vec![dep],
+      );
+      block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
+        chunk_name,
+        chunk_preload.or(dynamic_import_preload),
+        chunk_prefetch.or(dynamic_import_prefetch),
+      )));
+      parser.blocks.push(block);
+      Some(true)
+    } else {
+      let ContextModuleScanResult {
+        context,
+        reg,
+        query,
+        fragment,
+        replaces,
+      } = create_context_dependency(&param);
+      let magic_comment_options = try_extract_webpack_magic_comment(
+        parser.source_file,
+        &parser.comments,
+        node.span,
+        dyn_imported.span(),
+        &mut parser.warning_diagnostics,
+      );
+      let _mode = magic_comment_options
+        .get_webpack_mode()
+        .map(|x| DynamicImportMode::from(x.as_str()));
+      let chunk_name = magic_comment_options
+        .get_webpack_chunk_name()
+        .map(|x| x.to_owned());
+      let chunk_prefetch = magic_comment_options
+        .get_webpack_prefetch()
+        .and_then(|x| parse_order_string(x.as_str()));
+      let chunk_preload = magic_comment_options
+        .get_webpack_preload()
+        .and_then(|x| parse_order_string(x.as_str()));
+      parser
+        .dependencies
+        .push(Box::new(ImportContextDependency::new(
+          import_call.span.real_lo(),
+          import_call.span.real_hi(),
           node.span.real_hi(),
-          request,
-          Some(span),
-          None,
-        ));
-        let mut block = AsyncDependenciesBlock::new(
-          *parser.module_identifier,
-          Some(DependencyLocation::new(span.start, span.end)),
-          None,
-          vec![dep],
-        );
-        block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-          chunk_name,
-          chunk_preload.or(dynamic_import_preload),
-          chunk_prefetch.or(dynamic_import_prefetch),
-        )));
-        parser.blocks.push(block);
-        // FIXME: align `parser.walk_expression` to webpack, which put into `context_dependency_helper`
-        parser.walk_template_expression(tpl);
-        Some(true)
-      }
-      _ => {
-        let Some(ContextModuleScanResult {
-          context,
-          reg,
-          query,
-          fragment,
-          replaces,
-        }) = scanner_context_module(dyn_imported.expr.as_ref())
-        else {
-          return None;
-        };
-        let magic_comment_options = try_extract_webpack_magic_comment(
-          parser.source_file,
-          &parser.comments,
-          node.span,
-          dyn_imported.span(),
-          &mut parser.warning_diagnostics,
-        );
-        let _mode = magic_comment_options
-          .get_webpack_mode()
-          .map(|x| DynamicImportMode::from(x.as_str()));
-        let chunk_name = magic_comment_options
-          .get_webpack_chunk_name()
-          .map(|x| x.to_owned());
-        let chunk_prefetch = magic_comment_options
-          .get_webpack_prefetch()
-          .and_then(|x| parse_order_string(x.as_str()));
-        let chunk_preload = magic_comment_options
-          .get_webpack_preload()
-          .and_then(|x| parse_order_string(x.as_str()));
-        parser
-          .dependencies
-          .push(Box::new(ImportContextDependency::new(
-            import_call.span.real_lo(),
-            import_call.span.real_hi(),
-            node.span.real_hi(),
-            ContextOptions {
-              mode: ContextMode::Lazy,
-              recursive: true,
-              reg_exp: context_reg_exp(&reg, ""),
-              include: None,
-              exclude: None,
-              category: DependencyCategory::Esm,
-              request: format!("{}{}{}", context.clone(), query, fragment),
-              context,
-              namespace_object: if parser.build_meta.strict_harmony_module {
-                ContextNameSpaceObject::Strict
-              } else {
-                ContextNameSpaceObject::Bool(true)
-              },
-              group_options: Some(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-                chunk_name,
-                chunk_preload.or(dynamic_import_preload),
-                chunk_prefetch.or(dynamic_import_prefetch),
-              ))),
-              start: node.span().real_lo(),
-              end: node.span().real_hi(),
+          ContextOptions {
+            mode: ContextMode::Lazy,
+            recursive: true,
+            reg_exp: context_reg_exp(&reg, ""),
+            include: None,
+            exclude: None,
+            category: DependencyCategory::Esm,
+            request: format!("{}{}{}", context.clone(), query, fragment),
+            context,
+            namespace_object: if parser.build_meta.strict_harmony_module {
+              ContextNameSpaceObject::Strict
+            } else {
+              ContextNameSpaceObject::Bool(true)
             },
-            replaces,
-            Some(node.span.into()),
-          )));
-        // FIXME: align `parser.walk_expression` to webpack, which put into `context_dependency_helper`
-        parser.walk_expression(&dyn_imported.expr);
-        Some(true)
-      }
+            group_options: Some(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
+              chunk_name,
+              chunk_preload.or(dynamic_import_preload),
+              chunk_prefetch.or(dynamic_import_prefetch),
+            ))),
+            start: node.span().real_lo(),
+            end: node.span().real_hi(),
+          },
+          replaces,
+          Some(node.span.into()),
+        )));
+      // FIXME: align `parser.walk_expression` to webpack, which put into `context_dependency_helper`
+      parser.walk_expression(&dyn_imported.expr);
+      Some(true)
     }
   }
 }