refactor: TS compiler and module graph

cli/global_state.rs

@@ -3,7 +3,9 @@ use crate::deno_dir;
 use crate::file_fetcher::SourceFileFetcher;
 use crate::flags;
 use crate::http_cache;
+use crate::import_map::ImportMap;
 use crate::lockfile::Lockfile;
+use crate::module_graph::ModuleGraphLoader;
 use crate::msg;
 use crate::permissions::Permissions;
 use crate::tsc::CompiledModule;
@@ -89,6 +91,78 @@ impl GlobalState {
     Ok(GlobalState(Arc::new(inner)))
   }
 
+  pub async fn prepare_module_load(
+    &self,
+    module_specifier: ModuleSpecifier,
+    maybe_referrer: Option<ModuleSpecifier>,
+    target_lib: TargetLib,
+    permissions: Permissions,
+    is_dyn_import: bool,
+    maybe_import_map: Option<ImportMap>,
+  ) -> Result<(), ErrBox> {
+    let state1 = self.clone();
+    let state2 = self.clone();
+    let module_specifier = module_specifier.clone();
+
+    // TODO(ry) Try to lift compile_lock as high up in the call stack for
+    // sanity.
+    let compile_lock = self.compile_lock.lock().await;
+
+    let mut module_graph_loader = ModuleGraphLoader::new(
+      self.file_fetcher.clone(),
+      maybe_import_map,
+      permissions.clone(),
+      is_dyn_import,
+      false,
+    );
+    module_graph_loader
+      .add_to_graph(&module_specifier, maybe_referrer)
+      .await?;
+    let module_graph = module_graph_loader.get_graph();
+
+    let out = self
+      .file_fetcher
+      .fetch_cached_source_file(&module_specifier, permissions.clone())
+      .expect("Source file not found");
+
+    // Check if we need to compile files
+    match out.media_type {
+      msg::MediaType::TypeScript
+      | msg::MediaType::TSX
+      | msg::MediaType::JSX => {
+        state1
+          .ts_compiler
+          .new_compile(
+            state1.clone(),
+            &out,
+            target_lib,
+            permissions,
+            module_graph,
+          )
+          .await?;
+      }
+      msg::MediaType::JavaScript => {
+        if state1.ts_compiler.compile_js {
+          state2
+            .ts_compiler
+            .new_compile(
+              state1.clone(),
+              &out,
+              target_lib,
+              permissions,
+              module_graph,
+            )
+            .await?;
+        }
+      }
+      _ => {}
+    };
+
+    drop(compile_lock);
+
+    Ok(())
+  }
+
   pub async fn fetch_compiled_module(
     &self,
     module_specifier: ModuleSpecifier,

cli/main.rs

@@ -388,14 +388,15 @@ async fn bundle_command(
   source_file: String,
   out_file: Option<PathBuf>,
 ) -> Result<(), ErrBox> {
-  let mut module_name = ModuleSpecifier::resolve_url_or_path(&source_file)?;
-  let url = module_name.as_url();
+  let mut module_specifier =
+    ModuleSpecifier::resolve_url_or_path(&source_file)?;
+  let url = module_specifier.as_url();
 
   // TODO(bartlomieju): fix this hack in ModuleSpecifier
   if url.scheme() == "file" {
     let a = deno_fs::normalize_path(&url.to_file_path().unwrap());
     let u = Url::from_file_path(a).unwrap();
-    module_name = ModuleSpecifier::from(u)
+    module_specifier = ModuleSpecifier::from(u)
   }
 
   debug!(">>>>> bundle START");
@@ -413,18 +414,37 @@ async fn bundle_command(
 
   let global_state = GlobalState::new(flags)?;
 
-  let bundle_result = tsc::bundle(
+  // TODO(bartlomieju): probably should respect --quiet flag
+  eprintln!("Bundling {}", module_specifier.to_string());
+
+  let output = tsc::bundle(
     &global_state,
     compiler_config,
-    module_name,
+    module_specifier,
     maybe_import_map,
-    out_file,
     global_state.flags.unstable,
   )
-  .await;
+  .await?;
 
   debug!(">>>>> bundle END");
-  bundle_result
+
+  let output_string = fmt::format_text(&output)?;
+
+  if let Some(out_file_) = out_file.as_ref() {
+    eprintln!("Emitting bundle to {:?}", out_file_);
+
+    let output_bytes = output_string.as_bytes();
+    let output_len = output_bytes.len();
+
+    deno_fs::write_file(out_file_, output_bytes, 0o666)?;
+    // TODO(bartlomieju): do we really need to show this info? (it doesn't respect --quiet flag)
+    // TODO(bartlomieju): add "humanFileSize" method
+    eprintln!("{} bytes emitted.", output_len);
+  } else {
+    println!("{}", output_string);
+  }
+
+  Ok(())
 }
 
 async fn doc_command(

cli/module_graph.rs

@@ -9,7 +9,7 @@ use crate::op_error::OpError;
 use crate::permissions::Permissions;
 use crate::swc_util::analyze_dependencies_and_references;
 use crate::swc_util::TsReferenceKind;
-use crate::tsc::get_available_libs;
+use crate::tsc::AVAILABLE_LIBS;
 use deno_core::ErrBox;
 use deno_core::ModuleSpecifier;
 use futures::stream::FuturesUnordered;
@@ -138,8 +138,9 @@ impl ModuleGraphLoader {
   pub async fn add_to_graph(
     &mut self,
     specifier: &ModuleSpecifier,
+    maybe_referrer: Option<ModuleSpecifier>,
   ) -> Result<(), ErrBox> {
-    self.download_module(specifier.clone(), None)?;
+    self.download_module(specifier.clone(), maybe_referrer)?;
 
     loop {
       let (specifier, source_file) =
@@ -238,10 +239,8 @@ impl ModuleGraphLoader {
       imports.push(import_descriptor);
     }
 
-    let available_libs = get_available_libs();
-
     for ref_desc in ref_descs {
-      if available_libs.contains(&ref_desc.specifier) {
+      if AVAILABLE_LIBS.contains(&ref_desc.specifier.as_str()) {
         continue;
       }
 
@@ -465,10 +464,8 @@ impl ModuleGraphLoader {
         imports.push(import_descriptor);
       }
 
-      let available_libs = get_available_libs();
-
       for ref_desc in ref_descs {
-        if available_libs.contains(&ref_desc.specifier) {
+        if AVAILABLE_LIBS.contains(&ref_desc.specifier.as_str()) {
           continue;
         }
 
@@ -537,7 +534,7 @@ mod tests {
       false,
       false,
     );
-    graph_loader.add_to_graph(&module_specifier).await?;
+    graph_loader.add_to_graph(&module_specifier, None).await?;
     Ok(graph_loader.get_graph())
   }
 

cli/state.rs

@@ -357,22 +357,43 @@ impl ModuleLoader for State {
   fn prepare_load(
     &self,
     _load_id: ModuleLoadId,
-    _module_specifier: &ModuleSpecifier,
-    _maybe_referrer: Option<String>,
-    _is_dyn_import: bool,
+    module_specifier: &ModuleSpecifier,
+    maybe_referrer: Option<String>,
+    is_dyn_import: bool,
   ) -> Pin<Box<dyn Future<Output = Result<(), ErrBox>>>> {
-    // TODO(bartlomieju):
-    // 1. recursively:
-    //    a) resolve specifier
-    //    b) check permission if dynamic import
-    //    c) fetch/download source code
-    //    d) parse the source code and extract all import/exports (dependencies)
-    //    e) add discovered deps and loop algorithm until no new dependencies
-    //        are discovered
-    // 2. run through appropriate compiler giving it access only to
-    //     discovered files
-
-    async { Ok(()) }.boxed_local()
+    let module_specifier = module_specifier.clone();
+    let state = self.borrow();
+    let target_lib = state.target_lib.clone();
+    let maybe_import_map = state.import_map.clone();
+    let permissions = if state.is_main && !is_dyn_import {
+      Permissions::allow_all()
+    } else {
+      state.permissions.clone()
+    };
+    let global_state = state.global_state.clone();
+    // TODO(bartlomieju): I'm not sure if it's correct to ignore
+    // bad referrer - this is the case for `Deno.core.evalContext()` where
+    // `ref_str` is `<unknown>`.
+    let maybe_referrer = if let Some(ref_str) = maybe_referrer {
+      ModuleSpecifier::resolve_url(&ref_str).ok()
+    } else {
+      None
+    };
+    drop(state);
+
+    async move {
+      global_state
+        .prepare_module_load(
+          module_specifier,
+          maybe_referrer,
+          target_lib,
+          permissions,
+          is_dyn_import,
+          maybe_import_map,
+        )
+        .await
+    }
+    .boxed_local()
   }
 }
 

cli/tests/error_005_missing_dynamic_import.ts.out

@@ -1 +1 @@
-error: Cannot resolve module "[WILDCARD]/bad-module.ts" from "[WILDCARD]/error_005_missing_dynamic_import.ts"
+error: Uncaught TypeError: Cannot resolve module "[WILDCARD]/bad-module.ts" from "[WILDCARD]/error_005_missing_dynamic_import.ts"

cli/tests/error_012_bad_dynamic_import_specifier.ts.out

@@ -1 +1,2 @@
-error: relative import path "bad-module.ts" not prefixed with / or ./ or ../ Imported from "[WILDCARD]/error_012_bad_dynamic_import_specifier.ts"
+Compile [WILDCARD]error_012_bad_dynamic_import_specifier.ts
+error: Uncaught TypeError: relative import path "bad-module.ts" not prefixed with / or ./ or ../ Imported from "[WILDCARD]/error_012_bad_dynamic_import_specifier.ts"

cli/tests/error_syntax.js.out

@@ -1,4 +1 @@
-error: Uncaught SyntaxError: Unexpected identifier
-(the following is a syntax error  ^^ ! )
-     ~~~~~~~~~
-    at [WILDCARD]tests/error_syntax.js:3:6
+error: Expected Comma, got Some(Word(following)) at [WILDCARD]tests/error_syntax.js:3:5

cli/tests/error_syntax_empty_trailing_line.mjs.out

@@ -1,2 +1 @@
-error: Uncaught SyntaxError: Unexpected end of input
-    at [WILDCARD]tests/error_syntax_empty_trailing_line.mjs:[WILDCARD]
+error: Unexpected eof at [WILDCARD]tests/error_syntax_empty_trailing_line.mjs:2:21

cli/tests/integration_tests.rs

@@ -1359,7 +1359,7 @@ itest!(error_004_missing_module {
 });
 
 itest!(error_005_missing_dynamic_import {
-  args: "run --reload --allow-read error_005_missing_dynamic_import.ts",
+  args: "run --reload --allow-read --quiet error_005_missing_dynamic_import.ts",
   exit_code: 1,
   output: "error_005_missing_dynamic_import.ts.out",
 });
@@ -1406,7 +1406,7 @@ itest!(error_014_catch_dynamic_import_error {
 });
 
 itest!(error_015_dynamic_import_permissions {
-  args: "run --reload error_015_dynamic_import_permissions.js",
+  args: "run --reload --quiet error_015_dynamic_import_permissions.js",
   output: "error_015_dynamic_import_permissions.out",
   exit_code: 1,
   http_server: true,