refactor(core): resolve_url_or_path and resolve_url_or_path_deprecated (#18170)

This commit changes current "deno_core::resolve_url_or_path" API to
"resolve_url_or_path_deprecated" and adds new "resolve_url_or_path"
API that requires to explicitly pass the directory from which paths
should be resolved to. 

Some of the call sites were updated to use the new API, the reminder
of them will be updated in a follow up PR.

Towards landing https://github.com/denoland/deno/pull/15454

12 files changed, 64 insertions, 43 deletions

diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
index 578b72adf..70fc34ca1 100644
--- a/cli/tools/bench.rs
+++ b/cli/tools/bench.rs
@@ -692,7 +692,8 @@ pub async fn run_benchmarks_with_watch(
 
         if let Some(changed) = &changed {
           for path in changed.iter().filter_map(|path| {
-            deno_core::resolve_url_or_path(&path.to_string_lossy()).ok()
+            deno_core::resolve_url_or_path_deprecated(&path.to_string_lossy())
+              .ok()
           }) {
             if modules.contains(&path) {
               modules_to_reload.push(specifier);
diff --git a/cli/tools/bundle.rs b/cli/tools/bundle.rs
index d75da5ec7..c1d4befb1 100644
--- a/cli/tools/bundle.rs
+++ b/cli/tools/bundle.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
-use deno_core::resolve_url_or_path;
+use deno_core::resolve_url_or_path_deprecated;
 use deno_graph::Module;
 use deno_runtime::colors;
 
@@ -40,7 +40,7 @@ pub async fn bundle(
     let source_file1 = &bundle_flags.source_file;
     let source_file2 = &bundle_flags.source_file;
     async move {
-      let module_specifier = resolve_url_or_path(source_file1)?;
+      let module_specifier = resolve_url_or_path_deprecated(source_file1)?;
 
       log::debug!(">>>>> bundle START");
       let ps = ProcState::from_options(cli_options).await?;
diff --git a/cli/tools/coverage/mod.rs b/cli/tools/coverage/mod.rs
index c7a4d58da..05ad853f8 100644
--- a/cli/tools/coverage/mod.rs
+++ b/cli/tools/coverage/mod.rs
@@ -655,8 +655,10 @@ pub async fn cover_files(
   };
 
   for script_coverage in script_coverages {
-    let module_specifier =
-      deno_core::resolve_url_or_path(&script_coverage.url)?;
+    let module_specifier = deno_core::resolve_url_or_path(
+      &script_coverage.url,
+      ps.options.initial_cwd(),
+    )?;
 
     let maybe_file = if module_specifier.scheme() == "file" {
       ps.file_fetcher.get_source(&module_specifier)
diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs
index 2ee80f6b7..38553e9ff 100644
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@@ -12,7 +12,6 @@ use crate::proc_state::ProcState;
 use crate::tsc::get_types_declaration_file_text;
 use deno_ast::MediaType;
 use deno_core::anyhow::bail;
-use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::resolve_path;
 use deno_core::resolve_url_or_path;
@@ -62,12 +61,13 @@ pub async fn print_docs(
       doc_parser.parse_module(&source_file_specifier)?.definitions
     }
     DocSourceFileFlag::Path(source_file) => {
-      let cwd = std::env::current_dir().context("Unable to get CWD")?;
-      let module_specifier = resolve_url_or_path(&source_file)?;
+      let module_specifier =
+        resolve_url_or_path(&source_file, ps.options.initial_cwd())?;
 
       // If the root module has external types, the module graph won't redirect it,
       // so instead create a dummy file which exports everything from the actual file being documented.
-      let root_specifier = resolve_path("./$deno$doc.ts", &cwd).unwrap();
+      let root_specifier =
+        resolve_path("./$deno$doc.ts", ps.options.initial_cwd()).unwrap();
       let root = File {
         local: PathBuf::from("./$deno$doc.ts"),
         maybe_types: None,
diff --git a/cli/tools/info.rs b/cli/tools/info.rs
index f7284154a..1cc60286d 100644
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@@ -34,7 +34,7 @@ use crate::util::checksum;
 pub async fn info(flags: Flags, info_flags: InfoFlags) -> Result<(), AnyError> {
   let ps = ProcState::build(flags).await?;
   if let Some(specifier) = info_flags.file {
-    let specifier = resolve_url_or_path(&specifier)?;
+    let specifier = resolve_url_or_path(&specifier, ps.options.initial_cwd())?;
     let mut loader = ps.create_graph_loader();
     loader.enable_loading_cache_info(); // for displaying the cache information
     let graph = ps
diff --git a/cli/tools/installer.rs b/cli/tools/installer.rs
index a43ec84d5..86291b2c9 100644
--- a/cli/tools/installer.rs
+++ b/cli/tools/installer.rs
@@ -308,7 +308,8 @@ async fn resolve_shim_data(
   let installation_dir = root.join("bin");
 
   // Check if module_url is remote
-  let module_url = resolve_url_or_path(&install_flags.module_url)?;
+  let cwd = std::env::current_dir().context("Unable to get CWD")?;
+  let module_url = resolve_url_or_path(&install_flags.module_url, &cwd)?;
 
   let name = if install_flags.name.is_some() {
     install_flags.name.clone()
@@ -408,7 +409,7 @@ async fn resolve_shim_data(
   }
 
   if let Some(import_map_path) = &flags.import_map_path {
-    let import_map_url = resolve_url_or_path(import_map_path)?;
+    let import_map_url = resolve_url_or_path(import_map_path, &cwd)?;
     executable_args.push("--import-map".to_string());
     executable_args.push(import_map_url.to_string());
   }
diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs
index 99dab6261..7224eb45f 100644
--- a/cli/tools/repl/mod.rs
+++ b/cli/tools/repl/mod.rs
@@ -5,7 +5,6 @@ use crate::args::ReplFlags;
 use crate::colors;
 use crate::proc_state::ProcState;
 use crate::worker::create_main_worker;
-use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::resolve_path;
 use deno_runtime::permissions::Permissions;
@@ -70,7 +69,8 @@ async fn read_eval_file(
   ps: &ProcState,
   eval_file: &str,
 ) -> Result<String, AnyError> {
-  let specifier = deno_core::resolve_url_or_path(eval_file)?;
+  let specifier =
+    deno_core::resolve_url_or_path(eval_file, ps.options.initial_cwd())?;
 
   let file = ps
     .file_fetcher
@@ -81,9 +81,9 @@ async fn read_eval_file(
 }
 
 pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
-  let cwd = std::env::current_dir().context("Unable to get CWD")?;
-  let main_module = resolve_path("./$deno$repl.ts", &cwd).unwrap();
   let ps = ProcState::build(flags).await?;
+  let main_module =
+    resolve_path("./$deno$repl.ts", ps.options.initial_cwd()).unwrap();
   let mut worker = create_main_worker(
     &ps,
     main_module,
diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs
index 1cd67fc97..3cd9730a7 100644
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@@ -11,7 +11,6 @@ use deno_ast::swc::visit::VisitWith;
 use deno_ast::DiagnosticsError;
 use deno_ast::ImportsNotUsedAsValues;
 use deno_ast::ModuleSpecifier;
-use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures::channel::mpsc::UnboundedReceiver;
 use deno_core::futures::FutureExt;
@@ -144,8 +143,11 @@ impl ReplSession {
     }
     assert_ne!(context_id, 0);
 
-    let cwd = std::env::current_dir().context("Unable to get CWD")?;
-    let referrer = deno_core::resolve_path("./$deno$repl.ts", &cwd).unwrap();
+    let referrer = deno_core::resolve_path(
+      "./$deno$repl.ts",
+      proc_state.options.initial_cwd(),
+    )
+    .unwrap();
 
     let mut repl_session = ReplSession {
       proc_state,
diff --git a/cli/tools/run.rs b/cli/tools/run.rs
index d949a1cdb..04ddcb4d9 100644
--- a/cli/tools/run.rs
+++ b/cli/tools/run.rs
@@ -9,6 +9,7 @@ use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::resolve_path;
 use deno_core::resolve_url_or_path;
+use deno_core::resolve_url_or_path_deprecated;
 use deno_graph::npm::NpmPackageReqReference;
 use deno_runtime::permissions::Permissions;
 use deno_runtime::permissions::PermissionsContainer;
@@ -56,7 +57,7 @@ To grant permissions, set them before the script argument. For example:
     if NpmPackageReqReference::from_str(&run_flags.script).is_ok() {
       ModuleSpecifier::parse(&run_flags.script)?
     } else {
-      resolve_url_or_path(&run_flags.script)?
+      resolve_url_or_path(&run_flags.script, ps.options.initial_cwd())?
     };
   let permissions = PermissionsContainer::new(Permissions::from_options(
     &ps.options.permissions_options(),
@@ -103,7 +104,7 @@ pub async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
 // code properly.
 async fn run_with_watch(flags: Flags, script: String) -> Result<i32, AnyError> {
   let flags = Arc::new(flags);
-  let main_module = resolve_url_or_path(&script)?;
+  let main_module = resolve_url_or_path_deprecated(&script)?;
   let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
   let mut ps =
     ProcState::build_for_file_watcher((*flags).clone(), sender.clone()).await?;
@@ -142,10 +143,11 @@ pub async fn eval_command(
 ) -> Result<i32, AnyError> {
   // deno_graph works off of extensions for local files to determine the media
   // type, and so our "fake" specifier needs to have the proper extension.
-  let cwd = std::env::current_dir().context("Unable to get CWD")?;
-  let main_module =
-    resolve_path(&format!("./$deno$eval.{}", eval_flags.ext), &cwd)?;
   let ps = ProcState::build(flags).await?;
+  let main_module = resolve_path(
+    &format!("./$deno$eval.{}", eval_flags.ext),
+    ps.options.initial_cwd(),
+  )?;
   let permissions = PermissionsContainer::new(Permissions::from_options(
     &ps.options.permissions_options(),
   )?);
diff --git a/cli/tools/standalone.rs b/cli/tools/standalone.rs
index 4573717a3..f0f53d417 100644
--- a/cli/tools/standalone.rs
+++ b/cli/tools/standalone.rs
@@ -39,11 +39,15 @@ pub async fn compile(
   compile_flags: CompileFlags,
 ) -> Result<(), AnyError> {
   let ps = ProcState::build(flags).await?;
-  let module_specifier = resolve_url_or_path(&compile_flags.source_file)?;
+  let module_specifier =
+    resolve_url_or_path(&compile_flags.source_file, ps.options.initial_cwd())?;
   let deno_dir = &ps.dir;
 
-  let output_path =
-    resolve_compile_executable_output_path(&compile_flags).await?;
+  let output_path = resolve_compile_executable_output_path(
+    &compile_flags,
+    ps.options.initial_cwd(),
+  )
+  .await?;
 
   let graph = Arc::try_unwrap(
     create_graph_and_maybe_check(module_specifier.clone(), &ps).await?,
@@ -282,8 +286,10 @@ async fn write_standalone_binary(
 
 async fn resolve_compile_executable_output_path(
   compile_flags: &CompileFlags,
+  current_dir: &Path,
 ) -> Result<PathBuf, AnyError> {
-  let module_specifier = resolve_url_or_path(&compile_flags.source_file)?;
+  let module_specifier =
+    resolve_url_or_path(&compile_flags.source_file, current_dir)?;
 
   let mut output = compile_flags.output.clone();
 
@@ -339,12 +345,15 @@ mod test {
 
   #[tokio::test]
   async fn resolve_compile_executable_output_path_target_linux() {
-    let path = resolve_compile_executable_output_path(&CompileFlags {
-      source_file: "mod.ts".to_string(),
-      output: Some(PathBuf::from("./file")),
-      args: Vec::new(),
-      target: Some("x86_64-unknown-linux-gnu".to_string()),
-    })
+    let path = resolve_compile_executable_output_path(
+      &CompileFlags {
+        source_file: "mod.ts".to_string(),
+        output: Some(PathBuf::from("./file")),
+        args: Vec::new(),
+        target: Some("x86_64-unknown-linux-gnu".to_string()),
+      },
+      &std::env::current_dir().unwrap(),
+    )
     .await
     .unwrap();
 
@@ -356,12 +365,15 @@ mod test {
 
   #[tokio::test]
   async fn resolve_compile_executable_output_path_target_windows() {
-    let path = resolve_compile_executable_output_path(&CompileFlags {
-      source_file: "mod.ts".to_string(),
-      output: Some(PathBuf::from("./file")),
-      args: Vec::new(),
-      target: Some("x86_64-pc-windows-msvc".to_string()),
-    })
+    let path = resolve_compile_executable_output_path(
+      &CompileFlags {
+        source_file: "mod.ts".to_string(),
+        output: Some(PathBuf::from("./file")),
+        args: Vec::new(),
+        target: Some("x86_64-pc-windows-msvc".to_string()),
+      },
+      &std::env::current_dir().unwrap(),
+    )
     .await
     .unwrap();
     assert_eq!(path.file_name().unwrap(), "file.exe");
diff --git a/cli/tools/test.rs b/cli/tools/test.rs
index 1feb83ca3..12f5d7c1f 100644
--- a/cli/tools/test.rs
+++ b/cli/tools/test.rs
@@ -799,7 +799,7 @@ fn extract_files_from_regex_blocks(
         writeln!(file_source, "{}", text.as_str()).unwrap();
       }
 
-      let file_specifier = deno_core::resolve_url_or_path(&format!(
+      let file_specifier = deno_core::resolve_url_or_path_deprecated(&format!(
         "{}${}-{}{}",
         specifier,
         file_line_index + line_offset + 1,
@@ -1428,7 +1428,8 @@ pub async fn run_tests_with_watch(
 
         if let Some(changed) = &changed {
           for path in changed.iter().filter_map(|path| {
-            deno_core::resolve_url_or_path(&path.to_string_lossy()).ok()
+            deno_core::resolve_url_or_path_deprecated(&path.to_string_lossy())
+              .ok()
           }) {
             if modules.contains(&path) {
               modules_to_reload.push(specifier);
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index e3536a00d..3198348e3 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -268,7 +268,7 @@ async fn create_graph(
   let entry_points = flags
     .specifiers
     .iter()
-    .map(|p| resolve_url_or_path(p))
+    .map(|p| resolve_url_or_path(p, ps.options.initial_cwd()))
     .collect::<Result<Vec<_>, _>>()?;
 
   ps.create_graph(entry_points).await