refactor(BREAKING): remove unused module parser build option and use …

…less Options (#399)

lib/lib.rs

@@ -263,11 +263,10 @@ pub async fn js_create_graph(
       BuildOptions {
         is_dynamic: false,
         resolver: maybe_resolver.as_ref().map(|r| r as &dyn Resolver),
-        file_system: Some(&NullFileSystem),
-        jsr_url_provider: None,
+        file_system: &NullFileSystem,
+        jsr_url_provider: Default::default(),
         npm_resolver: None,
-        module_analyzer: None,
-        module_parser: None,
+        module_analyzer: Default::default(),
         imports,
         reporter: None,
         workspace_members: &[],
@@ -318,7 +317,7 @@ pub fn js_parse_module(
     content: content.into(),
     file_system: &NullFileSystem,
     maybe_resolver: maybe_resolver.as_ref().map(|r| r as &dyn Resolver),
-    maybe_module_analyzer: None,
+    module_analyzer: Default::default(),
     maybe_npm_resolver: None,
   }) {
     Ok(module) => {

src/analyzer.rs

@@ -18,6 +18,7 @@ use serde::Serialize;
 use serde::Serializer;
 
 use crate::graph::Position;
+use crate::DefaultModuleAnalyzer;
 
 /// Matches the `@deno-types` pragma.
 static DENO_TYPES_RE: Lazy<Regex> = Lazy::new(|| {
@@ -314,6 +315,12 @@ pub trait ModuleAnalyzer {
   ) -> Result<ModuleInfo, ParseDiagnostic>;
 }
 
+impl<'a> Default for &'a dyn ModuleAnalyzer {
+  fn default() -> &'a dyn ModuleAnalyzer {
+    &DefaultModuleAnalyzer
+  }
+}
+
 #[cfg(test)]
 mod test {
   use std::collections::HashMap;

src/ast.rs

@@ -209,18 +209,29 @@ impl<'a> ModuleParser for CapturingModuleParser<'a> {
   }
 }
 
-/// Default module analyzer that analyzes based on a deno_ast::ParsedSource.
 #[derive(Default)]
-pub struct DefaultModuleAnalyzer<'a> {
-  parser: Option<&'a dyn ModuleParser>,
+pub struct DefaultModuleAnalyzer;
+
+impl ModuleAnalyzer for DefaultModuleAnalyzer {
+  fn analyze(
+    &self,
+    specifier: &deno_ast::ModuleSpecifier,
+    source: Arc<str>,
+    media_type: MediaType,
+  ) -> Result<ModuleInfo, ParseDiagnostic> {
+    ParserModuleAnalyzer::default().analyze(specifier, source, media_type)
+  }
 }
 
-impl<'a> DefaultModuleAnalyzer<'a> {
+/// Default module analyzer that analyzes based on a deno_ast::ParsedSource.
+pub struct ParserModuleAnalyzer<'a> {
+  parser: &'a dyn ModuleParser,
+}
+
+impl<'a> ParserModuleAnalyzer<'a> {
   /// Creates a new module analyzer.
   pub fn new(parser: &'a dyn ModuleParser) -> Self {
-    Self {
-      parser: Some(parser),
-    }
+    Self { parser }
   }
 
   /// Gets the module info from a parsed source.
@@ -263,23 +274,29 @@ impl<'a> DefaultModuleAnalyzer<'a> {
   }
 }
 
-impl<'a> ModuleAnalyzer for DefaultModuleAnalyzer<'a> {
+impl<'a> Default for ParserModuleAnalyzer<'a> {
+  fn default() -> Self {
+    Self {
+      parser: &DefaultModuleParser,
+    }
+  }
+}
+
+impl<'a> ModuleAnalyzer for ParserModuleAnalyzer<'a> {
   fn analyze(
     &self,
     specifier: &deno_ast::ModuleSpecifier,
     source: Arc<str>,
     media_type: MediaType,
   ) -> Result<ModuleInfo, ParseDiagnostic> {
-    let default_parser = DefaultModuleParser;
-    let parser = self.parser.unwrap_or(&default_parser);
-    let parsed_source = parser.parse_module(ParseOptions {
+    let parsed_source = self.parser.parse_module(ParseOptions {
       specifier,
       source,
       media_type,
       // scope analysis is not necessary for module parsing
       scope_analysis: false,
     })?;
-    Ok(DefaultModuleAnalyzer::module_info(&parsed_source))
+    Ok(ParserModuleAnalyzer::module_info(&parsed_source))
   }
 }
 
@@ -323,7 +340,7 @@ impl ModuleAnalyzer for CapturingModuleAnalyzer {
     media_type: MediaType,
   ) -> Result<ModuleInfo, ParseDiagnostic> {
     let capturing_parser = self.as_capturing_parser();
-    let module_analyzer = DefaultModuleAnalyzer::new(&capturing_parser);
+    let module_analyzer = ParserModuleAnalyzer::new(&capturing_parser);
     module_analyzer.analyze(specifier, source, media_type)
   }
 }
@@ -606,7 +623,7 @@ mod tests {
       })
       .unwrap();
     let text_info = parsed_source.text_info();
-    let module_info = DefaultModuleAnalyzer::module_info(&parsed_source);
+    let module_info = ParserModuleAnalyzer::module_info(&parsed_source);
     let dependencies = module_info.dependencies;
     assert_eq!(dependencies.len(), 6);
 
@@ -683,7 +700,7 @@ mod tests {
         scope_analysis: false,
       })
       .unwrap();
-    let module_info = DefaultModuleAnalyzer::module_info(&parsed_source);
+    let module_info = ParserModuleAnalyzer::module_info(&parsed_source);
     let text_info = parsed_source.text_info();
     let dependencies = module_info.dependencies;
     assert_eq!(dependencies.len(), 10);
@@ -720,7 +737,7 @@ mod tests {
           scope_analysis: false,
         })
         .unwrap();
-      let module_info = DefaultModuleAnalyzer::module_info(&parsed_source);
+      let module_info = ParserModuleAnalyzer::module_info(&parsed_source);
       let dependencies = module_info.dependencies;
       assert_eq!(dependencies.len(), 2);
       let dep = dependencies[0].as_static().unwrap();
@@ -771,7 +788,7 @@ const f = new Set();
         scope_analysis: false,
       })
       .unwrap();
-    let module_info = DefaultModuleAnalyzer::module_info(&parsed_source);
+    let module_info = ParserModuleAnalyzer::module_info(&parsed_source);
     let dependencies = module_info.jsdoc_imports;
     assert_eq!(
       dependencies,
@@ -840,8 +857,7 @@ const f = new Set();
 /* @jsxImportSource preact */
 export {};
 "#;
-    let analyzer = DefaultModuleAnalyzer::new(&DefaultModuleParser);
-    let module_info = analyzer
+    let module_info = DefaultModuleAnalyzer
       .analyze(&specifier, source.into(), MediaType::Tsx)
       .unwrap();
     assert_eq!(

src/fast_check/transform.rs

@@ -19,9 +19,9 @@ use deno_ast::ParsedSource;
 use deno_ast::SourceRange;
 use deno_ast::SourceRangedForSpanned;
 
-use crate::DefaultModuleAnalyzer;
 use crate::ModuleGraph;
 use crate::ModuleInfo;
+use crate::ParserModuleAnalyzer;
 use crate::WorkspaceMember;
 
 use super::range_finder::ModulePublicRanges;
@@ -115,7 +115,7 @@ pub fn transform(
   if !transformer.diagnostics.is_empty() {
     return Err(transformer.diagnostics);
   }
-  let module_info = DefaultModuleAnalyzer::module_info_from_swc(
+  let module_info = ParserModuleAnalyzer::module_info_from_swc(
     parsed_source.media_type(),
     &module,
     parsed_source.text_info(),

src/fast_check/transform_dts.rs

@@ -936,7 +936,7 @@ mod tests {
   use crate::source::Source;
   use crate::symbols::RootSymbol;
   use crate::BuildOptions;
-  use crate::DefaultModuleParser;
+  use crate::CapturingModuleAnalyzer;
   use crate::GraphKind;
   use crate::ModuleGraph;
   use url::Url;
@@ -955,20 +955,20 @@ mod tests {
       )],
       vec![],
     );
-    let parser = DefaultModuleParser {};
+    let analyzer = CapturingModuleAnalyzer::default();
     let mut graph = ModuleGraph::new(GraphKind::All);
     graph
       .build(
         vec![specifier.clone()],
         &mut loader,
         BuildOptions {
-          module_parser: Some(&parser),
+          module_analyzer: &analyzer,
           ..Default::default()
         },
       )
       .await;
 
-    let root_sym = RootSymbol::new(&graph, &parser);
+    let root_sym = RootSymbol::new(&graph, &analyzer);
 
     let module_info = root_sym
       .module_from_specifier(&specifier)

src/graph.rs

@@ -11,8 +11,6 @@ use crate::analyzer::SpecifierWithRange;
 use crate::analyzer::TypeScriptReference;
 #[cfg(feature = "fast_check")]
 use crate::fast_check::FastCheckDtsModule;
-use crate::CapturingModuleAnalyzer;
-use crate::ModuleParser;
 use crate::ReferrerImports;
 
 use crate::fast_check::FastCheckDiagnostic;
@@ -1001,7 +999,7 @@ pub struct BuildFastCheckTypeGraphOptions<'a> {
   pub fast_check_cache: Option<&'a dyn crate::fast_check::FastCheckCache>,
   pub fast_check_dts: bool,
   pub jsr_url_provider: Option<&'a dyn JsrUrlProvider>,
-  pub module_parser: Option<&'a dyn ModuleParser>,
+  pub module_parser: Option<&'a dyn crate::ModuleParser>,
   pub resolver: Option<&'a dyn Resolver>,
   pub npm_resolver: Option<&'a dyn NpmResolver>,
   /// Whether to fill workspace members with fast check TypeScript data.
@@ -1016,15 +1014,14 @@ pub struct BuildOptions<'a> {
   /// be extra modules such as TypeScript's "types" option or JSX
   /// runtime types.
   pub imports: Vec<ReferrerImports>,
-  pub file_system: Option<&'a dyn FileSystem>,
-  pub jsr_url_provider: Option<&'a dyn JsrUrlProvider>,
-  pub resolver: Option<&'a dyn Resolver>,
+  pub executor: &'a dyn Executor,
+  pub file_system: &'a dyn FileSystem,
+  pub jsr_url_provider: &'a dyn JsrUrlProvider,
+  pub module_analyzer: &'a dyn ModuleAnalyzer,
   pub npm_resolver: Option<&'a dyn NpmResolver>,
-  pub module_analyzer: Option<&'a dyn ModuleAnalyzer>,
-  pub module_parser: Option<&'a dyn ModuleParser>,
   pub reporter: Option<&'a dyn Reporter>,
+  pub resolver: Option<&'a dyn Resolver>,
   pub workspace_members: &'a [WorkspaceMember],
-  pub executor: &'a dyn Executor,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -1444,25 +1441,17 @@ impl ModuleGraph {
     loader: &mut dyn Loader,
     options: BuildOptions<'a>,
   ) -> Vec<BuildDiagnostic> {
-    let default_jsr_url_provider = DefaultJsrUrlProvider;
-    let default_module_parser = CapturingModuleAnalyzer::default();
-    #[cfg(not(target_arch = "wasm32"))]
-    let file_system = RealFileSystem;
-    #[cfg(target_arch = "wasm32")]
-    let file_system = NullFileSystem;
     Builder::build(
       self,
       roots,
       options.imports,
       options.is_dynamic,
-      options.file_system.unwrap_or(&file_system),
-      options
-        .jsr_url_provider
-        .unwrap_or(&default_jsr_url_provider),
+      options.file_system,
+      options.jsr_url_provider,
       options.resolver,
       options.npm_resolver,
       loader,
-      options.module_analyzer.unwrap_or(&default_module_parser),
+      options.module_analyzer,
       options.reporter,
       options.workspace_members,
       options.executor,
@@ -1494,7 +1483,7 @@ impl ModuleGraph {
       return;
     }
 
-    let default_module_parser = CapturingModuleAnalyzer::default();
+    let default_module_parser = crate::CapturingModuleAnalyzer::default();
     let root_symbol = crate::symbols::RootSymbol::new(
       self,
       options.module_parser.unwrap_or(&default_module_parser),
@@ -4588,7 +4577,7 @@ where
 #[cfg(test)]
 mod tests {
   use crate::packages::JsrPackageInfoVersion;
-  use crate::DefaultModuleAnalyzer;
+  use crate::ParserModuleAnalyzer;
   use deno_ast::dep::ImportAttribute;
   use pretty_assertions::assert_eq;
   use serde_json::json;
@@ -4656,7 +4645,7 @@ mod tests {
   #[test]
   fn test_module_dependency_includes() {
     let specifier = ModuleSpecifier::parse("file:///a.ts").unwrap();
-    let module_analyzer = DefaultModuleAnalyzer::default();
+    let module_analyzer = ParserModuleAnalyzer::default();
     let content: Arc<[u8]> = Arc::from(
       b"import * as b from \"./b.ts\";\nimport * as c from \"./b.ts\"".to_vec(),
     );