Switch back to resolving based on multiple args.

denoland · dsherret · Jul 4, 2024 · Jun 17, 2024 · Jun 18, 2024 · Jun 18, 2024
commit 7e6644fbf99263d8f79e11caa0c37b3f86b4dd36
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -376,3  376,6 @@ opt-level = 3
 opt-level = 3
 [profile.release.package.zstd-sys]
 opt-level = 3
 
 [patch.crates-io]
 deno_config = { path = "../deno_config" }
diff --git a/cli/args/flags.rs b/cli/args/flags.rs
@@ -36,6  36,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use crate::args::resolve_no_prompt;
 use crate::util::collections::CheckedSet;
 use crate::util::fs::canonicalize_path;
 
 use super::flags_net;
@@ -862,28  863,41 @@ impl Flags {
     args
   }
 
-  /// Extract the directory path the config file should be discovered from.
   /// Extract the directory paths the config file should be discovered from.
   ///
   /// Returns `None` if the config file should not be auto-discovered.
-  pub fn config_path_arg(&self, current_dir: &Path) -> Option<PathBuf> {
   pub fn config_path_args(&self, current_dir: &Path) -> Option<Vec<PathBuf>> {
     fn resolve_multiple_files(
       files: &[String],
       current_dir: &Path,
     ) -> Vec<PathBuf> {
       let mut seen = CheckedSet::with_capacity(files.len());
       let result = files
         .iter()
         .filter_map(|p| {
           let path = normalize_path(current_dir.join(p).parent()?);
           if seen.insert(&path) {
             Some(path)
           } else {
             None
           }
         })
         .collect::<Vec<_>>();
       if result.is_empty() {
         vec![current_dir.to_path_buf()]
       } else {
         result
       }
     }
 
     use DenoSubcommand::*;
     match &self.subcommand {
-      Fmt(FmtFlags { files, .. }) => Some(
-        files
-          .include
-          .iter()
-          .filter_map(|p| Some(normalize_path(current_dir.join(p).parent()?)))
-          .next()
-          .unwrap_or_else(|| current_dir.to_path_buf()),
-      ),
-      Lint(LintFlags { files, .. }) => Some(
-        files
-          .include
-          .iter()
-          .filter_map(|p| Some(normalize_path(current_dir.join(p).parent()?)))
-          .next()
-          .unwrap_or_else(|| current_dir.to_path_buf()),
-      ),
       Fmt(FmtFlags { files, .. }) => {
         Some(resolve_multiple_files(&files.include, current_dir))
       }
       Lint(LintFlags { files, .. }) => {
         Some(resolve_multiple_files(&files.include, current_dir))
       }
       Run(RunFlags { script, .. })
       | Compile(CompileFlags {
         source_file: script,
@@ -894,17  908,17 @@ impl Flags {
             || module_specifier.scheme() == "npm"
           {
             if let Ok(p) = module_specifier.to_file_path() {
-              Some(p.parent().unwrap().to_path_buf())
               Some(vec![p.parent().unwrap().to_path_buf()])
             } else {
-              Some(current_dir.to_path_buf())
               Some(vec![current_dir.to_path_buf()])
             }
           } else {
             // When the entrypoint doesn't have file: scheme (it's the remote
             // script), then we don't auto discover config file.
             None
           }
         } else {
-          Some(current_dir.to_path_buf())
           Some(vec![current_dir.to_path_buf()])
         }
       }
       Task(TaskFlags {
@@ -914,11  928,11 @@ impl Flags {
         // attempt to resolve the config file from the task subcommand's
         // `--cwd` when specified
         match canonicalize_path(&PathBuf::from(path)) {
-          Ok(path) => Some(path),
-          Err(_) => Some(current_dir.to_path_buf()),
           Ok(path) => Some(vec![path]),
           Err(_) => Some(vec![current_dir.to_path_buf()]),
         }
       }
-      _ => Some(current_dir.to_path_buf()),
       _ => Some(vec![current_dir.to_path_buf()]),
     }
   }
 
@@ -9236,30  9250,44 @@ mod tests {
   fn test_config_path_args() {
     let flags = flags_from_vec(svec!["deno", "run", "foo.js"]).unwrap();
     let cwd = std::env::current_dir().unwrap();
-    assert_eq!(flags.config_path_arg(&cwd), Some(cwd.clone()));
 
     assert_eq!(flags.config_path_args(&cwd), Some(vec![cwd.clone()]));
 
     let flags = flags_from_vec(svec!["deno", "run", "sub_dir/foo.js"]).unwrap();
     let cwd = std::env::current_dir().unwrap();
     assert_eq!(
-      flags.config_path_arg(&cwd),
-      Some(cwd.join("sub_dir").clone())
       flags.config_path_args(&cwd),
       Some(vec![cwd.join("sub_dir").clone()])
     );
 
     let flags =
       flags_from_vec(svec!["deno", "run", "https://example.com/foo.js"])
         .unwrap();
-    assert_eq!(flags.config_path_arg(&cwd), None);
     assert_eq!(flags.config_path_args(&cwd), None);
 
     let flags =
-      flags_from_vec(svec!["deno", "lint", "dir/a.js", "dir/b.js"]).unwrap();
-    assert_eq!(flags.config_path_arg(&cwd), Some(cwd.join("dir")));
       flags_from_vec(svec!["deno", "lint", "dir/a/a.js", "dir/b/b.js"])
         .unwrap();
     assert_eq!(
       flags.config_path_args(&cwd),
       Some(vec![cwd.join("dir/a/"), cwd.join("dir/b/")])
     );
 
     let flags = flags_from_vec(svec!["deno", "lint"]).unwrap();
-    assert_eq!(flags.config_path_arg(&cwd), Some(cwd.clone()));
     assert_eq!(flags.config_path_args(&cwd), Some(vec![cwd.clone()]));
 
-    let flags =
-      flags_from_vec(svec!["deno", "fmt", "dir/a.js", "dir/b.js"]).unwrap();
-    assert_eq!(flags.config_path_arg(&cwd), Some(cwd.join("dir")));
     let flags = flags_from_vec(svec![
       "deno",
       "fmt",
       "dir/a/a.js",
       "dir/a/a2.js",
       "dir/b.js"
     ])
     .unwrap();
     assert_eq!(
       flags.config_path_args(&cwd),
       Some(vec![cwd.join("dir/a/"), cwd.join("dir/b/")])
     );
   }
 
   #[test]

diff --git a/cli/args/mod.rs b/cli/args/mod.rs
@@ -892,9  892,9 @@ impl CliOptions {
 
     let workspace = match &flags.config_flag {
       deno_config::ConfigFlag::Discover => {
-        if let Some(start_dir) = flags.config_path_arg(&initial_cwd) {
         if let Some(start_dirs) = flags.config_path_args(&initial_cwd) {
           Workspace::discover(
-            WorkspaceDiscoverStart::Dir(&start_dir),
             WorkspaceDiscoverStart::Dirs(&start_dirs),
             &WorkspaceDiscoverOptions {
               fs: &DenoConfigFsAdapter::new(&RealFs),
               pkg_json_cache: Some(

diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
@@ -3557,7  3557,9 @@ impl Inner {
       .unwrap_or_else(|| self.initial_cwd.clone());
     // todo: we need a way to convert config data to a Workspace
     let workspace = Arc::new(Workspace::discover(
-      deno_config::workspace::WorkspaceDiscoverStart::Dir(&initial_cwd),
       deno_config::workspace::WorkspaceDiscoverStart::Dirs(&[
         initial_cwd.clone()
       ]),
       &WorkspaceDiscoverOptions {
         fs: &DenoConfigFsAdapter::new(&deno_runtime::deno_fs::RealFs),
         pkg_json_cache: None,

diff --git a/cli/util/collections.rs b/cli/util/collections.rs
@@ -0,0  1,36 @@
 use std::marker::PhantomData;
 
 pub struct CheckedSet<T: std::hash::Hash   ?Sized> {
   _kind: PhantomData<T>,
   checked: std::collections::HashSet<u64>,
 }
 
 impl<T: std::hash::Hash   ?Sized> Default for CheckedSet<T> {
   fn default() -> Self {
     Self {
       _kind: Default::default(),
       checked: Default::default(),
     }
   }
 }
 
 impl<T: std::hash::Hash   ?Sized> CheckedSet<T> {
   pub fn with_capacity(capacity: usize) -> Self {
     Self {
       _kind: PhantomData,
       checked: std::collections::HashSet::with_capacity(capacity),
     }
   }
 
   pub fn insert(&mut self, value: &T) -> bool {
     self.checked.insert(self.get_hash(value))
   }
 
   fn get_hash(&self, value: &T) -> u64 {
     use std::collections::hash_map::DefaultHasher;
     use std::hash::Hasher;
     let mut hasher = DefaultHasher::new();
     value.hash(&mut hasher);
     hasher.finish()
   }
 }
diff --git a/cli/util/mod.rs b/cli/util/mod.rs
@@ -2,6  2,7 @@
 
 // Note: Only add code in this folder that has no application specific logic
 pub mod checksum;
 pub mod collections;
 pub mod console;
 pub mod diff;
 pub mod display;