feature(zubanls): ✨ wasm support for zubanls

wasm language server with a subset of capabilities, ty #137 for `local_fs_stub` & `memfs`

Author: AlphaNecron

Cargo.lock

@@ -48,6 +48,7 @@ toml_edit = "*"
 tracing = "*"
 tracing-subscriber = { version = "*", features = ["time", "local-time"] }
 tracing-appender = "*"
+wasm-bindgen = "0.2"
 
 # Dev dependencies
 insta = "*"

Cargo.toml

@@ -15,7 +15,12 @@ utils.workspace = true
 
 anyhow.workspace = true
 tracing.workspace = true
+glob = "*"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 crossbeam-channel.workspace = true
 notify.workspace = true
-glob = "*"
 same-file = "*"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen.workspace = true

crates/vfs/Cargo.toml

@@ -1,7 +1,15 @@
 // Some parts are copied from rust-analyzer
 
 mod glob_abs_path;
+
+#[cfg(not(target_arch = "wasm32"))]
+mod local_fs;
+
+#[cfg(target_arch = "wasm32")]
+#[path = "local_fs_stub.rs"]
 mod local_fs;
+
+mod memory;
 mod normalized_path;
 mod path;
 mod tree;
@@ -10,18 +18,34 @@ mod workspaces;
 
 use std::{borrow::Cow, path::Path, sync::Arc};
 
-use crossbeam_channel::Receiver;
-
 pub use glob_abs_path::GlobAbsPath;
+
 pub use local_fs::{LocalFS, SimpleLocalFS};
+
+#[cfg(target_arch = "wasm32")]
+pub use memory::InMemoryFs;
+
 pub use normalized_path::NormalizedPath;
 pub use path::AbsPath;
 pub use tree::{DirOrFile, Directory, DirectoryEntry, Entries, FileEntry, FileIndex, Parent};
 pub use vfs::{InvalidationResult, PathWithScheme, Vfs, VfsFile, VfsPanicRecovery};
 pub use workspaces::{Workspace, WorkspaceKind};
 
+#[cfg(not(target_arch = "wasm32"))]
+pub use crossbeam_channel::Receiver;
+
+#[cfg(not(target_arch = "wasm32"))]
 pub type NotifyEvent = notify::Result<notify::Event>;
 
+#[cfg(target_arch = "wasm32")]
+pub type NotifyEvent = ();
+
+#[cfg(target_arch = "wasm32")]
+use std::marker::PhantomData;
+
+#[cfg(target_arch = "wasm32")]
+pub type Receiver<T> = PhantomData<T>;
+
 /// Interface for reading and watching files.                                  
 pub trait VfsHandler: Sync + Send {
     /// Load the content of the given file, returning [`None`] if it does not  

crates/vfs/src/lib.rs

@@ -0,0 +1,83 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use crate::{
+    AbsPath, DirectoryEntry, Entries, NormalizedPath, NotifyEvent, Parent, PathWithScheme,
+    VfsHandler,
+};
+
+pub type SimpleLocalFS = LocalFS;
+
+#[derive(Clone, Default)]
+pub struct LocalFS;
+
+impl LocalFS {
+    pub fn without_watcher() -> Self {
+        Self
+    }
+    pub fn with_watcher<T>(_: T) -> Self {
+        Self
+    }
+    pub fn watch<P: AsRef<Path>>(&self, _: P) {}
+    pub fn current_dir(&self) -> Arc<AbsPath> {
+        self.unchecked_abs_path("")
+    }
+    pub fn normalized_path_from_current_dir(&self, p: &str) -> Arc<NormalizedPath> {
+        self.normalize_rc_path(self.absolute_path(&self.current_dir(), p))
+    }
+}
+
+impl VfsHandler for LocalFS {
+    fn read_and_watch_file(&self, _: &PathWithScheme) -> Option<String> {
+        None
+    }
+    fn notify_receiver(&self) -> Option<&crate::Receiver<NotifyEvent>> {
+        None
+    }
+    fn on_invalidated_in_memory_file(&self, _: PathWithScheme) {}
+    fn read_and_watch_dir(&self, _: &str, _: Parent) -> Entries {
+        Entries::from_vec(vec![])
+    }
+    fn read_and_watch_entry(&self, _: &str, _: Parent, _: &str) -> Option<DirectoryEntry> {
+        None
+    }
+    fn separator(&self) -> char {
+        '/'
+    }
+    fn split_off_folder<'a>(&self, path: &'a str) -> (&'a str, Option<&'a str>) {
+        if path.is_empty() {
+            return (path, None);
+        }
+        if let Some(pos) = path
+            .as_bytes()
+            .iter()
+            .position(|b| *b == b'/' || *b == b'\\')
+        {
+            let (head, tail) = path.split_at(pos);
+            (
+                head,
+                if tail.len() > 1 {
+                    Some(&tail[1..])
+                } else {
+                    None
+                },
+            )
+        } else {
+            (path, None)
+        }
+    }
+    fn join(&self, path: &AbsPath, name: &str) -> Arc<AbsPath> {
+        let p = Path::new(&**path);
+        let joined = if p.as_os_str().is_empty() {
+            PathBuf::from(name)
+        } else {
+            p.join(name)
+        };
+        self.unchecked_abs_path(joined.to_str().unwrap_or(name))
+    }
+    fn is_case_sensitive(&self) -> bool {
+        true
+    }
+}