fix(node): support re-exported esm modules in cjs export analysis

Cargo.toml

@@ -50,7 +50,7 @@ license = "MIT"
 repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
-deno_ast = { version = "=0.46.0", features = ["transpiling"] }
+deno_ast = { version = "=0.46.1", features = ["transpiling"] }
 deno_core = { version = "0.340.0" }
 
 deno_bench_util = { version = "0.187.0", path = "./bench_util" }

cli/Cargo.toml

@@ -67,7 +67,7 @@ winapi.workspace = true
 winres.workspace = true
 
 [dependencies]
-deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "proposal", "react", "sourcemap", "transforms", "typescript", "view", "visit"] }
+deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "proposal", "react", "sourcemap", "transforms", "typescript", "view", "visit", "utils"] }
 deno_cache_dir = { workspace = true, features = ["sync"] }
 deno_config = { workspace = true, features = ["sync", "workspace"] }
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }

cli/cache/node.rs

@@ -137,6 +137,8 @@ impl NodeAnalysisCacheInner {
 
 #[cfg(test)]
 mod test {
+  use deno_ast::ModuleExportsAndReExports;
+
   use super::*;
 
   #[test]
@@ -148,10 +150,10 @@ mod test {
       .get_cjs_analysis("file.js", CacheDBHash::new(2))
       .unwrap()
       .is_none());
-    let cjs_analysis = CliCjsAnalysis::Cjs {
+    let cjs_analysis = CliCjsAnalysis::Cjs(ModuleExportsAndReExports {
       exports: vec!["export1".to_string()],
       reexports: vec!["re-export1".to_string()],
-    };
+    });
     cache
       .set_cjs_analysis("file.js", CacheDBHash::new(2), &cjs_analysis)
       .unwrap();

cli/factory.rs

@@ -80,6 +80,7 @@ use crate::http_util::HttpClientProvider;
 use crate::module_loader::CliModuleLoaderFactory;
 use crate::module_loader::ModuleLoadPreparer;
 use crate::node::CliCjsCodeAnalyzer;
+use crate::node::CliCjsModuleExportAnalyzer;
 use crate::node::CliNodeCodeTranslator;
 use crate::node::CliNodeResolver;
 use crate::node::CliPackageJsonResolver;
@@ -261,6 +262,7 @@ impl<T> Deferred<T> {
 struct CliFactoryServices {
   blob_store: Deferred<Arc<BlobStore>>,
   caches: Deferred<Arc<Caches>>,
+  cjs_module_export_analyzer: Deferred<Arc<CliCjsModuleExportAnalyzer>>,
   cjs_tracker: Deferred<Arc<CliCjsTracker>>,
   cli_options: Deferred<Arc<CliOptions>>,
   code_cache: Deferred<Arc<CodeCache>>,
@@ -804,17 +806,17 @@ impl CliFactory {
     Ok(())
   }
 
-  pub async fn node_code_translator(
+  pub async fn cjs_module_export_analyzer(
     &self,
-  ) -> Result<&Arc<CliNodeCodeTranslator>, AnyError> {
+  ) -> Result<&Arc<CliCjsModuleExportAnalyzer>, AnyError> {
     self
       .services
-      .node_code_translator
+      .cjs_module_export_analyzer
       .get_or_try_init_async(async {
         let node_resolver = self.node_resolver().await?.clone();
         let cjs_code_analyzer = self.create_cjs_code_analyzer()?;
 
-        Ok(Arc::new(NodeCodeTranslator::new(
+        Ok(Arc::new(CliCjsModuleExportAnalyzer::new(
           cjs_code_analyzer,
           self.in_npm_pkg_checker()?.clone(),
           node_resolver,
@@ -826,6 +828,21 @@ impl CliFactory {
       .await
   }
 
+  pub async fn node_code_translator(
+    &self,
+  ) -> Result<&Arc<CliNodeCodeTranslator>, AnyError> {
+    self
+      .services
+      .node_code_translator
+      .get_or_try_init_async(async {
+        let module_export_analyzer = self.cjs_module_export_analyzer().await?;
+        Ok(Arc::new(NodeCodeTranslator::new(
+          module_export_analyzer.clone(),
+        )))
+      })
+      .await
+  }
+
   fn create_cjs_code_analyzer(&self) -> Result<CliCjsCodeAnalyzer, AnyError> {
     let caches = self.caches()?;
     let node_analysis_cache = NodeAnalysisCache::new(caches.node_analysis_db());
@@ -1025,7 +1042,7 @@ impl CliFactory {
   ) -> Result<DenoCompileBinaryWriter, AnyError> {
     let cli_options = self.cli_options()?;
     Ok(DenoCompileBinaryWriter::new(
-      self.create_cjs_code_analyzer()?,
+      self.cjs_module_export_analyzer().await?,
       self.cjs_tracker()?,
       self.cli_options()?,
       self.deno_dir()?,

cli/lib/standalone/binary.rs

@@ -9,7 +9,6 @@ use deno_runtime::deno_permissions::PermissionsOptions;
 use deno_runtime::deno_telemetry::OtelConfig;
 use deno_semver::Version;
 use indexmap::IndexMap;
-use node_resolver::analyze::CjsAnalysisExports;
 use serde::Deserialize;
 use serde::Serialize;
 use url::Url;
@@ -130,7 +129,8 @@ impl<'a> DenoRtDeserializable<'a> for SpecifierId {
 #[derive(Deserialize, Serialize)]
 pub enum CjsExportAnalysisEntry {
   Esm,
-  Cjs(CjsAnalysisExports),
+  Cjs(Vec<String>),
+  Error(String),
 }
 
 const HAS_TRANSPILED_FLAG: u8 = 1 << 0;

cli/node.rs

@@ -4,6 +4,7 @@ use std::borrow::Cow;
 use std::sync::Arc;
 
 use deno_ast::MediaType;
+use deno_ast::ModuleExportsAndReExports;
 use deno_ast::ModuleSpecifier;
 use deno_error::JsErrorBox;
 use deno_graph::ParsedSourceStore;
@@ -12,6 +13,8 @@ use deno_runtime::deno_fs;
 use node_resolver::analyze::CjsAnalysis as ExtNodeCjsAnalysis;
 use node_resolver::analyze::CjsAnalysisExports;
 use node_resolver::analyze::CjsCodeAnalyzer;
+use node_resolver::analyze::CjsModuleExportAnalyzer;
+use node_resolver::analyze::EsmAnalysisMode;
 use node_resolver::analyze::NodeCodeTranslator;
 use node_resolver::DenoIsBuiltInNodeModuleChecker;
 use serde::Deserialize;
@@ -24,6 +27,13 @@ use crate::npm::CliNpmResolver;
 use crate::resolver::CliCjsTracker;
 use crate::sys::CliSys;
 
+pub type CliCjsModuleExportAnalyzer = CjsModuleExportAnalyzer<
+  CliCjsCodeAnalyzer,
+  DenoInNpmPackageChecker,
+  DenoIsBuiltInNodeModuleChecker,
+  CliNpmResolver,
+  CliSys,
+>;
 pub type CliNodeCodeTranslator = NodeCodeTranslator<
   CliCjsCodeAnalyzer,
   DenoInNpmPackageChecker,
@@ -42,11 +52,11 @@ pub type CliPackageJsonResolver = node_resolver::PackageJsonResolver<CliSys>;
 pub enum CliCjsAnalysis {
   /// The module was found to be an ES module.
   Esm,
+  /// The module was found to be an ES module and
+  /// it was analyzed for imports and exports.
+  EsmAnalysis(ModuleExportsAndReExports),
   /// The module was CJS.
-  Cjs {
-    exports: Vec<String>,
-    reexports: Vec<String>,
-  },
+  Cjs(ModuleExportsAndReExports),
 }
 
 pub struct CliCjsCodeAnalyzer {
@@ -75,6 +85,7 @@ impl CliCjsCodeAnalyzer {
     &self,
     specifier: &ModuleSpecifier,
     source: &str,
+    esm_analysis_mode: EsmAnalysisMode,
   ) -> Result<CliCjsAnalysis, JsErrorBox> {
     let source_hash = CacheDBHash::from_hashable(source);
     if let Some(analysis) =
@@ -85,17 +96,16 @@ impl CliCjsCodeAnalyzer {
 
     let media_type = MediaType::from_specifier(specifier);
     if media_type == MediaType::Json {
-      return Ok(CliCjsAnalysis::Cjs {
-        exports: vec![],
-        reexports: vec![],
-      });
+      return Ok(CliCjsAnalysis::Cjs(Default::default()));
     }
 
     let cjs_tracker = self.cjs_tracker.clone();
     let is_maybe_cjs = cjs_tracker
       .is_maybe_cjs(specifier, media_type)
       .map_err(JsErrorBox::from_err)?;
-    let analysis = if is_maybe_cjs {
+    let analysis = if is_maybe_cjs
+      || esm_analysis_mode == EsmAnalysisMode::SourceImportsAndExports
+    {
       let maybe_parsed_source = self
         .parsed_source_cache
         .as_ref()
@@ -118,22 +128,27 @@ impl CliCjsCodeAnalyzer {
               })
             })
             .map_err(JsErrorBox::from_err)?;
-          let is_script = parsed_source.compute_is_script();
-          let is_cjs = cjs_tracker
-            .is_cjs_with_known_is_script(
-              parsed_source.specifier(),
-              media_type,
-              is_script,
-            )
-            .map_err(JsErrorBox::from_err)?;
+          let is_script = is_maybe_cjs && parsed_source.compute_is_script();
+          let is_cjs = is_maybe_cjs
+            && cjs_tracker
+              .is_cjs_with_known_is_script(
+                parsed_source.specifier(),
+                media_type,
+                is_script,
+              )
+              .map_err(JsErrorBox::from_err)?;
           if is_cjs {
             let analysis = parsed_source.analyze_cjs();
-            Ok(CliCjsAnalysis::Cjs {
-              exports: analysis.exports,
-              reexports: analysis.reexports,
-            })
+            Ok(CliCjsAnalysis::Cjs(analysis))
           } else {
-            Ok(CliCjsAnalysis::Esm)
+            match esm_analysis_mode {
+              EsmAnalysisMode::SourceOnly => Ok(CliCjsAnalysis::Esm),
+              EsmAnalysisMode::SourceImportsAndExports => {
+                Ok(CliCjsAnalysis::EsmAnalysis(
+                  parsed_source.analyze_es_runtime_exports(),
+                ))
+              }
+            }
           }
         }
       })
@@ -157,6 +172,7 @@ impl CjsCodeAnalyzer for CliCjsCodeAnalyzer {
     &self,
     specifier: &ModuleSpecifier,
     source: Option<Cow<'a, str>>,
+    esm_analysis_mode: EsmAnalysisMode,
   ) -> Result<ExtNodeCjsAnalysis<'a>, JsErrorBox> {
     let source = match source {
       Some(source) => source,
@@ -180,13 +196,22 @@ impl CjsCodeAnalyzer for CliCjsCodeAnalyzer {
         }
       }
     };
-    let analysis = self.inner_cjs_analysis(specifier, &source).await?;
+    let analysis = self
+      .inner_cjs_analysis(specifier, &source, esm_analysis_mode)
+      .await?;
     match analysis {
-      CliCjsAnalysis::Esm => Ok(ExtNodeCjsAnalysis::Esm(source)),
-      CliCjsAnalysis::Cjs { exports, reexports } => {
+      CliCjsAnalysis::Esm => Ok(ExtNodeCjsAnalysis::Esm(source, None)),
+      CliCjsAnalysis::EsmAnalysis(analysis) => Ok(ExtNodeCjsAnalysis::Esm(
+        source,
+        Some(CjsAnalysisExports {
+          exports: analysis.exports,
+          reexports: analysis.reexports,
+        }),
+      )),
+      CliCjsAnalysis::Cjs(analysis) => {
         Ok(ExtNodeCjsAnalysis::Cjs(CjsAnalysisExports {
-          exports,
-          reexports,
+          exports: analysis.exports,
+          reexports: analysis.reexports,
         }))
       }
     }

cli/rt/node.rs

@@ -13,6 +13,7 @@ use deno_resolver::npm::NpmReqResolver;
 use deno_runtime::deno_fs::FileSystem;
 use node_resolver::analyze::CjsAnalysis;
 use node_resolver::analyze::CjsAnalysisExports;
+use node_resolver::analyze::EsmAnalysisMode;
 use node_resolver::analyze::NodeCodeTranslator;
 use node_resolver::DenoIsBuiltInNodeModuleChecker;
 
@@ -96,11 +97,17 @@ impl CjsCodeAnalyzer {
           match data {
             CjsExportAnalysisEntry::Esm => {
               cjs_tracker.set_is_known_script(specifier, false);
-              CjsAnalysis::Esm(source)
+              CjsAnalysis::Esm(source, None)
             }
-            CjsExportAnalysisEntry::Cjs(analysis) => {
+            CjsExportAnalysisEntry::Cjs(exports) => {
               cjs_tracker.set_is_known_script(specifier, true);
-              CjsAnalysis::Cjs(analysis)
+              CjsAnalysis::Cjs(CjsAnalysisExports {
+                exports,
+                reexports: Vec::new(), // already resolved
+              })
+            }
+            CjsExportAnalysisEntry::Error(err) => {
+              return Err(JsErrorBox::generic(err));
             }
           }
         }
@@ -119,11 +126,11 @@ impl CjsCodeAnalyzer {
             }
           }
           // assume ESM as we don't have access to swc here
-          CjsAnalysis::Esm(source)
+          CjsAnalysis::Esm(source, None)
         }
       }
     } else {
-      CjsAnalysis::Esm(source)
+      CjsAnalysis::Esm(source, None)
     };
 
     Ok(analysis)
@@ -136,6 +143,7 @@ impl node_resolver::analyze::CjsCodeAnalyzer for CjsCodeAnalyzer {
     &self,
     specifier: &Url,
     source: Option<Cow<'a, str>>,
+    _esm_analysis_mode: EsmAnalysisMode,
   ) -> Result<CjsAnalysis<'a>, JsErrorBox> {
     let source = match source {
       Some(source) => source,

cli/rt/run.rs

@@ -73,6 +73,7 @@ use deno_runtime::permissions::RuntimePermissionDescriptorParser;
 use deno_runtime::WorkerExecutionMode;
 use deno_runtime::WorkerLogLevel;
 use deno_semver::npm::NpmPackageReqReference;
+use node_resolver::analyze::CjsModuleExportAnalyzer;
 use node_resolver::analyze::NodeCodeTranslator;
 use node_resolver::cache::NodeResolutionSys;
 use node_resolver::errors::ClosestPkgJsonError;
@@ -153,18 +154,9 @@ impl ModuleLoader for EmbeddedModuleLoader {
     &self,
     raw_specifier: &str,
     referrer: &str,
-    kind: ResolutionKind,
+    _kind: ResolutionKind,
   ) -> Result<Url, ModuleLoaderError> {
     let referrer = if referrer == "." {
-      if kind != ResolutionKind::MainModule {
-        return Err(
-          JsErrorBox::generic(format!(
-            "Expected to resolve main module, got {:?} instead.",
-            kind
-          ))
-          .into(),
-        );
-      }
       let current_dir = std::env::current_dir().unwrap();
       deno_core::resolve_path(".", &current_dir)
         .map_err(JsErrorBox::from_err)?
@@ -807,14 +799,16 @@ pub async fn run(
   }));
   let cjs_esm_code_analyzer =
     CjsCodeAnalyzer::new(cjs_tracker.clone(), modules.clone(), sys.clone());
-  let node_code_translator = Arc::new(NodeCodeTranslator::new(
+  let cjs_module_export_analyzer = Arc::new(CjsModuleExportAnalyzer::new(
     cjs_esm_code_analyzer,
     in_npm_pkg_checker,
     node_resolver.clone(),
     npm_resolver.clone(),
     pkg_json_resolver.clone(),
     sys.clone(),
   ));
+  let node_code_translator =
+    Arc::new(NodeCodeTranslator::new(cjs_module_export_analyzer));
   let workspace_resolver = {
     let import_map = match metadata.workspace_resolver.import_map {
       Some(import_map) => Some(