refactor(ext/node): combine `deno_node::Fs` with `deno_fs::FileSystem` (#18991)

7 files changed, 26 insertions, 42 deletions

diff --git a/cli/build.rs b/cli/build.rs
index 6cedb53ce..8e6b670e2 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -326,6 +326,7 @@ deno_core::extension!(
 fn create_cli_snapshot(snapshot_path: PathBuf) {
   // NOTE(bartlomieju): ordering is important here, keep it in sync with
   // `runtime/worker.rs`, `runtime/web_worker.rs` and `runtime/build.rs`!
+  let fs = Arc::new(deno_fs::RealFs);
   let extensions: Vec<Extension> = vec![
     deno_webidl::deno_webidl::init_ops(),
     deno_console::deno_console::init_ops(),
@@ -360,11 +361,8 @@ fn create_cli_snapshot(snapshot_path: PathBuf) {
     deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
     deno_http::deno_http::init_ops(),
     deno_io::deno_io::init_ops(Default::default()),
-    deno_fs::deno_fs::init_ops::<PermissionsContainer>(
-      false,
-      Arc::new(deno_fs::RealFs),
-    ),
-    deno_node::deno_node::init_ops::<PermissionsContainer>(None, None),
+    deno_fs::deno_fs::init_ops::<PermissionsContainer>(false, fs.clone()),
+    deno_node::deno_node::init_ops::<PermissionsContainer>(None, fs),
     cli::init_ops_and_esm(), // NOTE: This needs to be init_ops_and_esm!
   ];
 
diff --git a/cli/factory.rs b/cli/factory.rs
index 295794a51..3bc5ef9e2 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -43,7 +43,6 @@ use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
 
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::RootCertStoreProvider;
@@ -133,6 +132,7 @@ struct CliFactoryServices {
   http_client: Deferred<Arc<HttpClient>>,
   emit_cache: Deferred<EmitCache>,
   emitter: Deferred<Arc<Emitter>>,
+  fs: Deferred<Arc<dyn deno_fs::FileSystem>>,
   graph_container: Deferred<Arc<ModuleGraphContainer>>,
   lockfile: Deferred<Option<Arc<Mutex<Lockfile>>>>,
   maybe_import_map: Deferred<Option<Arc<ImportMap>>>,
@@ -146,7 +146,6 @@ struct CliFactoryServices {
   module_graph_builder: Deferred<Arc<ModuleGraphBuilder>>,
   module_load_preparer: Deferred<Arc<ModuleLoadPreparer>>,
   node_code_translator: Deferred<Arc<CliNodeCodeTranslator>>,
-  node_fs: Deferred<Arc<dyn deno_node::NodeFs>>,
   node_resolver: Deferred<Arc<NodeResolver>>,
   npm_api: Deferred<Arc<CliNpmRegistryApi>>,
   npm_cache: Deferred<Arc<NpmCache>>,
@@ -245,6 +244,10 @@ impl CliFactory {
     })
   }
 
+  pub fn fs(&self) -> &Arc<dyn deno_fs::FileSystem> {
+    self.services.fs.get_or_init(|| Arc::new(deno_fs::RealFs))
+  }
+
   pub fn maybe_lockfile(&self) -> &Option<Arc<Mutex<Lockfile>>> {
     self
       .services
@@ -292,13 +295,6 @@ impl CliFactory {
       .await
   }
 
-  pub fn node_fs(&self) -> &Arc<dyn deno_node::NodeFs> {
-    self
-      .services
-      .node_fs
-      .get_or_init(|| Arc::new(deno_node::RealFs))
-  }
-
   pub async fn npm_resolver(&self) -> Result<&Arc<CliNpmResolver>, AnyError> {
     self
       .services
@@ -306,7 +302,7 @@ impl CliFactory {
       .get_or_try_init_async(async {
         let npm_resolution = self.npm_resolution().await?;
         let npm_fs_resolver = create_npm_fs_resolver(
-          self.node_fs().clone(),
+          self.fs().clone(),
           self.npm_cache()?.clone(),
           self.text_only_progress_bar(),
           CliNpmRegistryApi::default_url().to_owned(),
@@ -437,7 +433,7 @@ impl CliFactory {
       .node_resolver
       .get_or_try_init_async(async {
         Ok(Arc::new(NodeResolver::new(
-          self.node_fs().clone(),
+          self.fs().clone(),
           self.npm_resolver().await?.clone(),
         )))
       })
@@ -458,7 +454,7 @@ impl CliFactory {
 
         Ok(Arc::new(NodeCodeTranslator::new(
           cjs_esm_analyzer,
-          self.node_fs().clone(),
+          self.fs().clone(),
           self.node_resolver().await?.clone(),
           self.npm_resolver().await?.clone(),
         )))
@@ -554,8 +550,7 @@ impl CliFactory {
     let node_code_translator = self.node_code_translator().await?.clone();
     let options = self.cli_options().clone();
     let main_worker_options = self.create_cli_main_worker_options()?;
-    let fs = Arc::new(deno_fs::RealFs);
-    let node_fs = self.node_fs().clone();
+    let fs = self.fs().clone();
     let root_cert_store_provider = self.root_cert_store_provider().clone();
     let node_resolver = self.node_resolver().await?.clone();
     let npm_resolver = self.npm_resolver().await?.clone();
@@ -582,7 +577,6 @@ impl CliFactory {
         )),
         root_cert_store_provider.clone(),
         fs.clone(),
-        node_fs.clone(),
         maybe_inspector_server.clone(),
         main_worker_options.clone(),
       )
@@ -613,8 +607,7 @@ impl CliFactory {
         ),
       )),
       self.root_cert_store_provider().clone(),
-      Arc::new(deno_fs::RealFs),
-      self.node_fs().clone(),
+      self.fs().clone(),
       self.maybe_inspector_server().clone(),
       self.create_cli_main_worker_options()?,
     ))
diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
index 83657a8ef..d00b8f313 100644
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@@ -9,7 +9,7 @@ use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::ModuleSpecifier;
-use deno_runtime::deno_node;
+use deno_runtime::deno_fs;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_node::PackageJson;
 use deno_runtime::deno_tls::rustls::RootCertStore;
@@ -458,7 +458,7 @@ fn create_lsp_structs(
   let resolution =
     Arc::new(NpmResolution::from_serialized(api.clone(), None, None));
   let fs_resolver = create_npm_fs_resolver(
-    Arc::new(deno_node::RealFs),
+    Arc::new(deno_fs::RealFs),
     npm_cache.clone(),
     &progress_bar,
     registry_url.clone(),
@@ -709,7 +709,7 @@ impl Inner {
       self.npm_resolution.snapshot(),
       None,
     ));
-    let node_fs = Arc::new(deno_node::RealFs);
+    let node_fs = Arc::new(deno_fs::RealFs);
     let npm_resolver = Arc::new(CliNpmResolver::new(
       npm_resolution.clone(),
       create_npm_fs_resolver(
diff --git a/cli/npm/resolvers/local.rs b/cli/npm/resolvers/local.rs
index b4cf5af27..038d9eea1 100644
--- a/cli/npm/resolvers/local.rs
+++ b/cli/npm/resolvers/local.rs
@@ -23,7 +23,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
 use deno_npm::NpmPackageCacheFolderId;
 use deno_npm::NpmPackageId;
 use deno_runtime::deno_core::futures;
-use deno_runtime::deno_node::NodeFs;
+use deno_runtime::deno_fs;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::PackageJson;
@@ -44,7 +44,7 @@ use super::common::NpmPackageFsResolver;
 /// and resolves packages from it.
 #[derive(Debug)]
 pub struct LocalNpmPackageResolver {
-  fs: Arc<dyn NodeFs>,
+  fs: Arc<dyn deno_fs::FileSystem>,
   cache: Arc<NpmCache>,
   progress_bar: ProgressBar,
   resolution: Arc<NpmResolution>,
@@ -55,7 +55,7 @@ pub struct LocalNpmPackageResolver {
 
 impl LocalNpmPackageResolver {
   pub fn new(
-    fs: Arc<dyn NodeFs>,
+    fs: Arc<dyn deno_fs::FileSystem>,
     cache: Arc<NpmCache>,
     progress_bar: ProgressBar,
     registry_url: Url,
@@ -94,7 +94,7 @@ impl LocalNpmPackageResolver {
       // Canonicalize the path so it's not pointing to the symlinked directory
       // in `node_modules` directory of the referrer.
       Some(path) => {
-        Ok(deno_core::strip_unc_prefix(self.fs.canonicalize(&path)?))
+        Ok(deno_core::strip_unc_prefix(self.fs.realpath_sync(&path)?))
       }
       None => bail!("could not find npm package for '{}'", specifier),
     }
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index 60402bd27..86d3840f3 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -18,7 +18,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
 use deno_npm::resolution::PackageReqNotFoundError;
 use deno_npm::resolution::SerializedNpmResolutionSnapshot;
 use deno_npm::NpmPackageId;
-use deno_runtime::deno_node;
+use deno_runtime::deno_fs;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NpmResolver;
@@ -270,7 +270,7 @@ impl NpmResolver for CliNpmResolver {
 }
 
 pub fn create_npm_fs_resolver(
-  fs: Arc<dyn deno_node::NodeFs>,
+  fs: Arc<dyn deno_fs::FileSystem>,
   cache: Arc<NpmCache>,
   progress_bar: &ProgressBar,
   registry_url: Url,
diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index 0f65db679..e00ab8ab2 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -31,7 +31,6 @@ use deno_core::ModuleType;
 use deno_core::ResolutionKind;
 use deno_graph::source::Resolver;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::rustls::RootCertStore;
 use deno_runtime::deno_tls::RootCertStoreProvider;
@@ -208,11 +207,11 @@ pub async fn run(
     http_client.clone(),
     progress_bar.clone(),
   ));
-  let node_fs = Arc::new(deno_node::RealFs);
+  let fs = Arc::new(deno_fs::RealFs);
   let npm_resolution =
     Arc::new(NpmResolution::from_serialized(npm_api.clone(), None, None));
   let npm_fs_resolver = create_npm_fs_resolver(
-    node_fs.clone(),
+    fs.clone(),
     npm_cache,
     &progress_bar,
     npm_registry_url,
@@ -225,7 +224,7 @@ pub async fn run(
     None,
   ));
   let node_resolver =
-    Arc::new(NodeResolver::new(node_fs.clone(), npm_resolver.clone()));
+    Arc::new(NodeResolver::new(fs.clone(), npm_resolver.clone()));
   let module_loader_factory = StandaloneModuleLoaderFactory {
     loader: EmbeddedModuleLoader {
       eszip: Arc::new(eszip),
@@ -254,8 +253,7 @@ pub async fn run(
     BlobStore::default(),
     Box::new(module_loader_factory),
     root_cert_store_provider,
-    Arc::new(deno_fs::RealFs),
-    node_fs,
+    fs,
     None,
     CliMainWorkerOptions {
       argv: metadata.argv,
diff --git a/cli/worker.rs b/cli/worker.rs
index 5216af263..4d8e500b7 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -99,7 +99,6 @@ struct SharedWorkerState {
   module_loader_factory: Box<dyn ModuleLoaderFactory>,
   root_cert_store_provider: Arc<dyn RootCertStoreProvider>,
   fs: Arc<dyn deno_fs::FileSystem>,
-  node_fs: Arc<dyn deno_node::NodeFs>,
   maybe_inspector_server: Option<Arc<InspectorServer>>,
 }
 
@@ -311,7 +310,6 @@ impl CliMainWorkerFactory {
     module_loader_factory: Box<dyn ModuleLoaderFactory>,
     root_cert_store_provider: Arc<dyn RootCertStoreProvider>,
     fs: Arc<dyn deno_fs::FileSystem>,
-    node_fs: Arc<dyn deno_node::NodeFs>,
     maybe_inspector_server: Option<Arc<InspectorServer>>,
     options: CliMainWorkerOptions,
   ) -> Self {
@@ -329,7 +327,6 @@ impl CliMainWorkerFactory {
         module_loader_factory,
         root_cert_store_provider,
         fs,
-        node_fs,
         maybe_inspector_server,
       }),
     }
@@ -450,7 +447,6 @@ impl CliMainWorkerFactory {
       should_wait_for_inspector_session: shared.options.inspect_wait,
       module_loader,
       fs: shared.fs.clone(),
-      node_fs: Some(shared.node_fs.clone()),
       npm_resolver: Some(shared.npm_resolver.clone()),
       get_error_class_fn: Some(&errors::get_error_class_name),
       cache_storage_dir,
@@ -576,7 +572,6 @@ fn create_web_worker_callback(
       source_map_getter: maybe_source_map_getter,
       module_loader,
       fs: shared.fs.clone(),
-      node_fs: Some(shared.node_fs.clone()),
       npm_resolver: Some(shared.npm_resolver.clone()),
       worker_type: args.worker_type,
       maybe_inspector_server,