refactor: update to deno_config 0.25 (#24645)

- Gets rid of WorkspaceMemberContext. It's now `Workspace` and
`WorkspaceDirectory`
- Uses the workspace cache in the lsp

* https://github.com/denoland/deno_config/pull/95
* https://github.com/denoland/deno_config/pull/96

10 files changed, 89 insertions, 91 deletions

diff --git a/cli/tools/compile.rs b/cli/tools/compile.rs
index e395c351b..5500f9512 100644
--- a/cli/tools/compile.rs
+++ b/cli/tools/compile.rs
@@ -77,15 +77,15 @@ pub async fn compile(
     graph
   };
 
-  let ts_config_for_emit =
-    cli_options.resolve_ts_config_for_emit(deno_config::TsConfigType::Emit)?;
+  let ts_config_for_emit = cli_options
+    .resolve_ts_config_for_emit(deno_config::deno_json::TsConfigType::Emit)?;
   let (transpile_options, emit_options) =
     crate::args::ts_config_to_transpile_and_emit_options(
       ts_config_for_emit.ts_config,
     )?;
   let parser = parsed_source_cache.as_capturing_parser();
   let root_dir_url = resolve_root_dir_from_specifiers(
-    cli_options.workspace.root_folder().0,
+    cli_options.workspace().root_dir(),
     graph.specifiers().map(|(s, _)| s).chain(
       cli_options
         .node_modules_dir_path()
diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs
index 79765a91d..138e0a47d 100644
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@@ -187,32 +187,31 @@ pub async fn doc(flags: Flags, doc_flags: DocFlags) -> Result<(), AnyError> {
       Default::default()
     };
 
-    let rewrite_map = if let Some(config_file) =
-      cli_options.workspace.resolve_start_ctx().maybe_deno_json()
-    {
-      let config = config_file.to_exports_config()?;
-
-      let rewrite_map = config
-        .clone()
-        .into_map()
-        .into_keys()
-        .map(|key| {
-          Ok((
-            config.get_resolved(&key)?.unwrap(),
-            key
-              .strip_prefix('.')
-              .unwrap_or(&key)
-              .strip_prefix('/')
-              .unwrap_or(&key)
-              .to_owned(),
-          ))
-        })
-        .collect::<Result<IndexMap<_, _>, AnyError>>()?;
-
-      Some(rewrite_map)
-    } else {
-      None
-    };
+    let rewrite_map =
+      if let Some(config_file) = cli_options.start_dir.maybe_deno_json() {
+        let config = config_file.to_exports_config()?;
+
+        let rewrite_map = config
+          .clone()
+          .into_map()
+          .into_keys()
+          .map(|key| {
+            Ok((
+              config.get_resolved(&key)?.unwrap(),
+              key
+                .strip_prefix('.')
+                .unwrap_or(&key)
+                .strip_prefix('/')
+                .unwrap_or(&key)
+                .to_owned(),
+            ))
+          })
+          .collect::<Result<IndexMap<_, _>, AnyError>>()?;
+
+        Some(rewrite_map)
+      } else {
+        None
+      };
 
     generate_docs_directory(
       doc_nodes_by_url,
diff --git a/cli/tools/fmt.rs b/cli/tools/fmt.rs
index 040991e7c..277a79cda 100644
--- a/cli/tools/fmt.rs
+++ b/cli/tools/fmt.rs
@@ -52,9 +52,9 @@ use crate::cache::IncrementalCache;
 pub async fn format(flags: Flags, fmt_flags: FmtFlags) -> Result<(), AnyError> {
   if fmt_flags.is_stdin() {
     let cli_options = CliOptions::from_flags(flags)?;
-    let start_ctx = cli_options.workspace.resolve_start_ctx();
-    let fmt_config = start_ctx
-      .to_fmt_config(FilePatterns::new_with_base(start_ctx.dir_path()))?;
+    let start_dir = &cli_options.start_dir;
+    let fmt_config = start_dir
+      .to_fmt_config(FilePatterns::new_with_base(start_dir.dir_path()))?;
     let fmt_options = FmtOptions::resolve(fmt_config, &fmt_flags);
     return format_stdin(
       &fmt_flags,
diff --git a/cli/tools/installer.rs b/cli/tools/installer.rs
index 9d5b6baf3..b7b9b4d96 100644
--- a/cli/tools/installer.rs
+++ b/cli/tools/installer.rs
@@ -3,6 +3,7 @@
 use crate::args::resolve_no_prompt;
 use crate::args::AddFlags;
 use crate::args::CaData;
+use crate::args::ConfigFlag;
 use crate::args::Flags;
 use crate::args::InstallFlags;
 use crate::args::InstallFlagsGlobal;
@@ -14,7 +15,6 @@ use crate::factory::CliFactory;
 use crate::http_util::HttpClientProvider;
 use crate::util::fs::canonicalize_path_maybe_not_exists;
 
-use deno_config::ConfigFlag;
 use deno_core::anyhow::Context;
 use deno_core::error::generic_error;
 use deno_core::error::AnyError;
@@ -571,11 +571,11 @@ fn is_in_path(dir: &Path) -> bool {
 mod tests {
   use super::*;
 
+  use crate::args::ConfigFlag;
   use crate::args::PermissionFlags;
   use crate::args::UninstallFlagsGlobal;
   use crate::args::UnstableConfig;
   use crate::util::fs::canonicalize_path;
-  use deno_config::ConfigFlag;
   use std::process::Command;
   use test_util::testdata_path;
   use test_util::TempDir;
diff --git a/cli/tools/lint/mod.rs b/cli/tools/lint/mod.rs
index 275426265..05458a7b0 100644
--- a/cli/tools/lint/mod.rs
+++ b/cli/tools/lint/mod.rs
@@ -8,10 +8,10 @@ use deno_ast::ModuleSpecifier;
 use deno_ast::ParsedSource;
 use deno_ast::SourceRange;
 use deno_ast::SourceTextInfo;
+use deno_config::deno_json::ConfigFile;
 use deno_config::glob::FileCollector;
 use deno_config::glob::FilePatterns;
-use deno_config::workspace::Workspace;
-use deno_config::workspace::WorkspaceMemberContext;
+use deno_config::workspace::WorkspaceDirectory;
 use deno_core::anyhow::anyhow;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
@@ -118,7 +118,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
           let mut linter = WorkspaceLinter::new(
             factory.caches()?.clone(),
             factory.module_graph_creator().await?.clone(),
-            cli_options.workspace.clone(),
+            cli_options.start_dir.clone(),
             &cli_options.resolve_workspace_lint_options(&lint_flags)?,
           );
           for paths_with_options in paths_with_options_batches {
@@ -126,7 +126,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
               .lint_files(
                 paths_with_options.options,
                 lint_config.clone(),
-                paths_with_options.ctx,
+                paths_with_options.dir,
                 paths_with_options.paths,
               )
               .await?;
@@ -147,16 +147,16 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
     let workspace_lint_options =
       cli_options.resolve_workspace_lint_options(&lint_flags)?;
     let success = if is_stdin {
-      let start_ctx = cli_options.workspace.resolve_start_ctx();
+      let start_dir = &cli_options.start_dir;
       let reporter_lock = Arc::new(Mutex::new(create_reporter(
         workspace_lint_options.reporter_kind,
       )));
-      let lint_config = start_ctx
-        .to_lint_config(FilePatterns::new_with_base(start_ctx.dir_path()))?;
+      let lint_config = start_dir
+        .to_lint_config(FilePatterns::new_with_base(start_dir.dir_path()))?;
       let lint_options = LintOptions::resolve(lint_config, &lint_flags);
       let lint_rules = get_config_rules_err_empty(
         lint_options.rules,
-        start_ctx.maybe_deno_json().map(|c| c.as_ref()),
+        start_dir.maybe_deno_json().map(|c| c.as_ref()),
       )?;
       let file_path = cli_options.initial_cwd().join(STDIN_FILE_NAME);
       let r = lint_stdin(&file_path, lint_rules.rules, deno_lint_config);
@@ -171,7 +171,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
       let mut linter = WorkspaceLinter::new(
         factory.caches()?.clone(),
         factory.module_graph_creator().await?.clone(),
-        cli_options.workspace.clone(),
+        cli_options.start_dir.clone(),
         &workspace_lint_options,
       );
       let paths_with_options_batches =
@@ -181,7 +181,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
           .lint_files(
             paths_with_options.options,
             deno_lint_config.clone(),
-            paths_with_options.ctx,
+            paths_with_options.dir,
             paths_with_options.paths,
           )
           .await?;
@@ -197,7 +197,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
 }
 
 struct PathsWithOptions {
-  ctx: WorkspaceMemberContext,
+  dir: WorkspaceDirectory,
   paths: Vec<PathBuf>,
   options: LintOptions,
 }
@@ -210,11 +210,11 @@ fn resolve_paths_with_options_batches(
     cli_options.resolve_lint_options_for_members(lint_flags)?;
   let mut paths_with_options_batches =
     Vec::with_capacity(members_lint_options.len());
-  for (ctx, lint_options) in members_lint_options {
+  for (dir, lint_options) in members_lint_options {
     let files = collect_lint_files(cli_options, lint_options.files.clone())?;
     if !files.is_empty() {
       paths_with_options_batches.push(PathsWithOptions {
-        ctx,
+        dir,
         paths: files,
         options: lint_options,
       });
@@ -232,7 +232,7 @@ type WorkspaceModuleGraphFuture =
 struct WorkspaceLinter {
   caches: Arc<Caches>,
   module_graph_creator: Arc<ModuleGraphCreator>,
-  workspace: Arc<Workspace>,
+  workspace_dir: Arc<WorkspaceDirectory>,
   reporter_lock: Arc<Mutex<Box<dyn LintReporter + Send>>>,
   workspace_module_graph: Option<WorkspaceModuleGraphFuture>,
   has_error: Arc<AtomicFlag>,
@@ -243,7 +243,7 @@ impl WorkspaceLinter {
   pub fn new(
     caches: Arc<Caches>,
     module_graph_creator: Arc<ModuleGraphCreator>,
-    workspace: Arc<Workspace>,
+    workspace_dir: Arc<WorkspaceDirectory>,
     workspace_options: &WorkspaceLintOptions,
   ) -> Self {
     let reporter_lock =
@@ -251,7 +251,7 @@ impl WorkspaceLinter {
     Self {
       caches,
       module_graph_creator,
-      workspace,
+      workspace_dir,
       reporter_lock,
       workspace_module_graph: None,
       has_error: Default::default(),
@@ -263,14 +263,14 @@ impl WorkspaceLinter {
     &mut self,
     lint_options: LintOptions,
     lint_config: LintConfig,
-    member_ctx: WorkspaceMemberContext,
+    member_dir: WorkspaceDirectory,
     paths: Vec<PathBuf>,
   ) -> Result<(), AnyError> {
     self.file_count += paths.len();
 
     let lint_rules = get_config_rules_err_empty(
       lint_options.rules,
-      member_ctx.maybe_deno_json().map(|c| c.as_ref()),
+      member_dir.maybe_deno_json().map(|c| c.as_ref()),
     )?;
     let incremental_cache = Arc::new(IncrementalCache::new(
       self.caches.lint_incremental_cache_db(),
@@ -282,7 +282,7 @@ impl WorkspaceLinter {
     if lint_rules.no_slow_types {
       if self.workspace_module_graph.is_none() {
         let module_graph_creator = self.module_graph_creator.clone();
-        let packages = self.workspace.jsr_packages_for_publish();
+        let packages = self.workspace_dir.jsr_packages_for_publish();
         self.workspace_module_graph = Some(
           async move {
             module_graph_creator
@@ -297,7 +297,7 @@ impl WorkspaceLinter {
       }
       let workspace_module_graph_future =
         self.workspace_module_graph.as_ref().unwrap().clone();
-      let publish_config = member_ctx.maybe_package_config();
+      let publish_config = member_dir.maybe_package_config();
       if let Some(publish_config) = publish_config {
         let has_error = self.has_error.clone();
         let reporter_lock = self.reporter_lock.clone();
@@ -989,7 +989,7 @@ fn sort_diagnostics(diagnostics: &mut [JsonLintDiagnostic]) {
 
 fn get_config_rules_err_empty(
   rules: LintRulesConfig,
-  maybe_config_file: Option<&deno_config::ConfigFile>,
+  maybe_config_file: Option<&ConfigFile>,
 ) -> Result<ConfiguredRules, AnyError> {
   let lint_rules = get_configured_rules(rules, maybe_config_file);
   if lint_rules.rules.is_empty() {
@@ -1026,7 +1026,7 @@ impl ConfiguredRules {
 
 pub fn get_configured_rules(
   rules: LintRulesConfig,
-  maybe_config_file: Option<&deno_config::ConfigFile>,
+  maybe_config_file: Option<&ConfigFile>,
 ) -> ConfiguredRules {
   const NO_SLOW_TYPES_NAME: &str = "no-slow-types";
   let implicit_no_slow_types =
@@ -1060,9 +1060,7 @@ pub fn get_configured_rules(
   }
 }
 
-fn get_default_tags(
-  maybe_config_file: Option<&deno_config::ConfigFile>,
-) -> Vec<String> {
+fn get_default_tags(maybe_config_file: Option<&ConfigFile>) -> Vec<String> {
   let mut tags = Vec::with_capacity(2);
   tags.push("recommended".to_string());
   if maybe_config_file.map(|c| c.is_package()).unwrap_or(false) {
diff --git a/cli/tools/registry/mod.rs b/cli/tools/registry/mod.rs
index a22384a52..2e781ccee 100644
--- a/cli/tools/registry/mod.rs
+++ b/cli/tools/registry/mod.rs
@@ -82,9 +82,9 @@ pub async fn publish(
 
   let directory_path = cli_factory.cli_options().initial_cwd();
   let cli_options = cli_factory.cli_options();
-  let publish_configs = cli_options.workspace.jsr_packages_for_publish();
+  let publish_configs = cli_options.start_dir.jsr_packages_for_publish();
   if publish_configs.is_empty() {
-    match cli_options.workspace.resolve_start_ctx().maybe_deno_json() {
+    match cli_options.start_dir.maybe_deno_json() {
       Some(deno_json) => {
         debug_assert!(!deno_json.is_package());
         bail!(
@@ -437,7 +437,7 @@ impl PublishPreparer {
     let Some((scope, name_no_scope)) = name_no_at.split_once('/') else {
       bail!("Invalid package name, use '@<scope_name>/<package_name> format");
     };
-    let file_patterns = package.member_ctx.to_publish_config()?.files;
+    let file_patterns = package.member_dir.to_publish_config()?.files;
 
     let tarball = deno_core::unsync::spawn_blocking({
       let diagnostics_collector = diagnostics_collector.clone();
diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs
index e3e2f1b55..4573f196d 100644
--- a/cli/tools/registry/pm.rs
+++ b/cli/tools/registry/pm.rs
@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use deno_ast::TextChange;
-use deno_config::FmtOptionsConfig;
+use deno_config::deno_json::FmtOptionsConfig;
 use deno_core::anyhow::anyhow;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
@@ -49,7 +49,7 @@ impl DenoConfigFormat {
 }
 
 enum DenoOrPackageJson {
-  Deno(Arc<deno_config::ConfigFile>, DenoConfigFormat),
+  Deno(Arc<deno_config::deno_json::ConfigFile>, DenoConfigFormat),
   Npm(Arc<deno_node::PackageJson>, Option<FmtOptionsConfig>),
 }
 
@@ -122,9 +122,9 @@ impl DenoOrPackageJson {
   fn from_flags(flags: Flags) -> Result<(Self, CliFactory), AnyError> {
     let factory = CliFactory::from_flags(flags.clone())?;
     let options = factory.cli_options();
-    let start_ctx = options.workspace.resolve_start_ctx();
+    let start_dir = &options.start_dir;
 
-    match (start_ctx.maybe_deno_json(), start_ctx.maybe_pkg_json()) {
+    match (start_dir.maybe_deno_json(), start_dir.maybe_pkg_json()) {
       // when both are present, for now,
       // default to deno.json
       (Some(deno), Some(_) | None) => Ok((
@@ -140,13 +140,14 @@ impl DenoOrPackageJson {
       (None, Some(_) | None) => {
         std::fs::write(options.initial_cwd().join("deno.json"), "{}\n")
           .context("Failed to create deno.json file")?;
+        drop(factory); // drop to prevent use
         log::info!("Created deno.json configuration file.");
         let factory = CliFactory::from_flags(flags.clone())?;
         let options = factory.cli_options().clone();
-        let start_ctx = options.workspace.resolve_start_ctx();
+        let start_dir = &options.start_dir;
         Ok((
           DenoOrPackageJson::Deno(
-            start_ctx.maybe_deno_json().cloned().ok_or_else(|| {
+            start_dir.maybe_deno_json().cloned().ok_or_else(|| {
               anyhow!("config not found, but it was just created")
             })?,
             DenoConfigFormat::Json,
diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs
index 1fbfae4f3..ee67bb014 100644
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@@ -254,7 +254,7 @@ impl ReplSession {
         ))
       })?;
     let ts_config_for_emit = cli_options
-      .resolve_ts_config_for_emit(deno_config::TsConfigType::Emit)?;
+      .resolve_ts_config_for_emit(deno_config::deno_json::TsConfigType::Emit)?;
     let (transpile_options, _) =
       crate::args::ts_config_to_transpile_and_emit_options(
         ts_config_for_emit.ts_config,
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index 9ab54f258..d2e16fb12 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -8,8 +8,9 @@ use crate::factory::CliFactory;
 use crate::npm::CliNpmResolver;
 use crate::task_runner;
 use crate::util::fs::canonicalize_path;
+use deno_config::deno_json::Task;
 use deno_config::workspace::TaskOrScript;
-use deno_config::workspace::Workspace;
+use deno_config::workspace::WorkspaceDirectory;
 use deno_config::workspace::WorkspaceTasksConfig;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
@@ -30,8 +31,8 @@ pub async fn execute_script(
 ) -> Result<i32, AnyError> {
   let factory = CliFactory::from_flags(flags)?;
   let cli_options = factory.cli_options();
-  let start_ctx = cli_options.workspace.resolve_start_ctx();
-  if !start_ctx.has_deno_or_pkg_json() {
+  let start_dir = &cli_options.start_dir;
+  if !start_dir.has_deno_or_pkg_json() {
     bail!("deno task couldn't find deno.json(c). See https://deno.land/manual@v{}/getting_started/configuration_file", env!("CARGO_PKG_VERSION"))
   }
   let force_use_pkg_json =
@@ -44,7 +45,7 @@ pub async fn execute_script(
         v == "1"
       })
       .unwrap_or(false);
-  let tasks_config = start_ctx.to_tasks_config()?;
+  let tasks_config = start_dir.to_tasks_config()?;
   let tasks_config = if force_use_pkg_json {
     tasks_config.with_only_pkg_json()
   } else {
@@ -56,7 +57,7 @@ pub async fn execute_script(
     None => {
       print_available_tasks(
         &mut std::io::stdout(),
-        &cli_options.workspace,
+        &cli_options.start_dir,
         &tasks_config,
       )?;
       return Ok(1);
@@ -143,7 +144,7 @@ pub async fn execute_script(
       if log::log_enabled!(log::Level::Error) {
         print_available_tasks(
           &mut std::io::stderr(),
-          &cli_options.workspace,
+          &cli_options.start_dir,
           &tasks_config,
         )?;
       }
@@ -204,7 +205,7 @@ fn output_task(task_name: &str, script: &str) {
 
 fn print_available_tasks(
   writer: &mut dyn std::io::Write,
-  workspace: &Arc<Workspace>,
+  workspace_dir: &Arc<WorkspaceDirectory>,
   tasks_config: &WorkspaceTasksConfig,
 ) -> Result<(), std::io::Error> {
   writeln!(writer, "{}", colors::green("Available tasks:"))?;
@@ -228,7 +229,8 @@ fn print_available_tasks(
         .as_ref()
         .map(|config| {
           let is_root = !is_cwd_root_dir
-            && config.folder_url == *workspace.root_folder().0.as_ref();
+            && config.folder_url
+              == *workspace_dir.workspace.root_dir().as_ref();
           config
             .tasks
             .iter()
@@ -242,13 +244,10 @@ fn print_available_tasks(
             .as_ref()
             .map(|config| {
               let is_root = !is_cwd_root_dir
-                && config.folder_url == *workspace.root_folder().0.as_ref();
+                && config.folder_url
+                  == *workspace_dir.workspace.root_dir().as_ref();
               config.tasks.iter().map(move |(k, v)| {
-                (
-                  is_root,
-                  false,
-                  (k, Cow::Owned(deno_config::Task::Definition(v.clone()))),
-                )
+                (is_root, false, (k, Cow::Owned(Task::Definition(v.clone()))))
               })
             })
             .into_iter()
@@ -275,10 +274,10 @@ fn print_available_tasks(
           }
         )?;
         let definition = match task.as_ref() {
-          deno_config::Task::Definition(definition) => definition,
-          deno_config::Task::Commented { definition, .. } => definition,
+          Task::Definition(definition) => definition,
+          Task::Commented { definition, .. } => definition,
         };
-        if let deno_config::Task::Commented { comments, .. } = task.as_ref() {
+        if let Task::Commented { comments, .. } = task.as_ref() {
           let slash_slash = colors::italic_gray("//");
           for comment in comments {
             writeln!(
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index bbb796a2a..73aada7cf 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -53,16 +53,17 @@ pub async fn vendor(
   validate_options(&mut cli_options, &output_dir)?;
   let factory = CliFactory::from_cli_options(Arc::new(cli_options));
   let cli_options = factory.cli_options();
-  if cli_options.workspace.config_folders().len() > 1 {
+  if cli_options.workspace().config_folders().len() > 1 {
     bail!("deno vendor is not supported in a workspace. Set `\"vendor\": true` in the workspace deno.json file instead");
   }
   let entry_points =
     resolve_entry_points(&vendor_flags, cli_options.initial_cwd())?;
-  let jsx_import_source =
-    cli_options.workspace.to_maybe_jsx_import_source_config()?;
+  let jsx_import_source = cli_options
+    .workspace()
+    .to_maybe_jsx_import_source_config()?;
   let module_graph_creator = factory.module_graph_creator().await?.clone();
   let workspace_resolver = factory.workspace_resolver().await?;
-  let root_folder = cli_options.workspace.root_folder().1;
+  let root_folder = cli_options.workspace().root_folder_configs();
   let maybe_config_file = root_folder.deno_json.as_ref();
   let output = build::build(build::BuildInput {
     entry_points,
@@ -189,7 +190,7 @@ fn validate_options(
   let import_map_specifier = options
     .resolve_specified_import_map_specifier()?
     .or_else(|| {
-      let config_file = options.workspace.root_folder().1.deno_json.as_ref()?;
+      let config_file = options.workspace().root_deno_json()?;
       config_file
         .to_import_map_specifier()
         .ok()