bangls支持绑定补全

Author: A4-Tacks

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bangls"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 
 [features]

tools/bangls/Cargo.toml

@@ -3,7 +3,7 @@ use crossbeam_channel::{Receiver, Sender};
 use linked_hash_map::LinkedHashMap;
 use lsp_server::{IoThreads, Message};
 use lsp_types::{CompletionItem, CompletionOptions, InitializeParams, MessageType, Position, ServerCapabilities, ShowMessageParams, TextDocumentSyncCapability, TextDocumentSyncKind, Uri, notification::{self, Notification}, request::{self, Request}};
-use syntax::{Compile, CompileMeta, EmulateInfo, Expand, LSP_DEBUG};
+use syntax::{Compile, CompileMeta, Emulate, EmulateInfo, Expand, LSP_DEBUG};
 
 fn main() {
     main_loop().unwrap();
@@ -44,7 +44,7 @@ fn main_loop() -> Result<()> {
     let _io = IoJoiner(Some(io));
     let server_capabilities = ServerCapabilities {
         completion_provider: Some(CompletionOptions {
-            trigger_characters: Some(vec![]),
+            trigger_characters: Some(vec![".".to_owned(), ">".to_owned()]),
             ..Default::default()
         }),
         text_document_sync: Some(TextDocumentSyncCapability::Kind(TextDocumentSyncKind::FULL)),
@@ -207,24 +207,34 @@ impl RequestHandler for request::Completion {
 }
 
 fn generate_completes(infos: &[EmulateInfo]) -> Vec<CompletionItem> {
-    let mut var_counter = LinkedHashMap::new();
+    let mut var_counter: LinkedHashMap<&syntax::Var, (u32, Vec<_>)> = LinkedHashMap::new();
     for info in infos {
-        for var in info.exist_vars.iter() {
+        for (kind, var) in info.exist_vars.iter() {
             if var.starts_with("__") {
                 continue;
             }
-            let slot: &mut u32 = var_counter.entry(var).or_default();
+            let (slot, kinds) = var_counter.entry(var).or_default();
             *slot += 1;
+            kinds.push(kind);
         }
     }
     let full_count = infos.len() as u32;
-    var_counter.iter().map(|(&var, &count)| {
+    var_counter.iter().map(|(&var, &(count, ref kinds))| {
         let is_full_deps = count == full_count;
+
+        let kind = kinds.iter().map(|kind| match kind {
+            Emulate::Const => format!("constant"),
+            Emulate::Binder => format!("binder"),
+            Emulate::ConstBind(var) => format!("const bind to `{var}`"),
+            Emulate::NakedBind(var) => format!("naked bind to `{var}`"),
+        }).collect::<Vec<_>>().join(" & ");
+
         let (label, detail) = if is_full_deps {
-            (var.to_string(), format!("full deps ({count}/{full_count})"))
+            (var.to_string(), format!("kind: {kind}\nfull deps ({count}/{full_count})"))
         } else {
-            (format!("{var}?"), format!("partial deps ({count}/{full_count})"))
+            (format!("{var}?"), format!("kind: {kind}\npartial deps ({count}/{full_count})"))
         };
+
         CompletionItem {
             label,
             detail: Some(detail),
@@ -239,7 +249,6 @@ trait NotificationHandler: Notification {
 }
 impl NotificationHandler for notification::DidOpenTextDocument {
     fn handle(ctx: &mut Ctx, param: Self::Params) -> Result<()> {
-        ctx.send_window_notif(MessageType::LOG, "open file")?;
         let file = ctx.open_files.entry(param.text_document.uri).or_default();
         *file = param.text_document.text;
         Ok(())

tools/bangls/src/main.rs

@@ -196,10 +196,8 @@ pub trait TakeHandle: Sized {
 impl TakeHandle for Var {
     fn take_handle(self, meta: &mut CompileMeta) -> Var {
         let mut this = self;
-        if let Some(raw_this) = this.strip_suffix(LSP_DEBUG)
-            && meta.is_emulated
-        {
-            meta.debug_status();
+        if let Some(raw_this) = this.strip_suffix(LSP_DEBUG) {
+            meta.debug_expand_env_status();
             this = raw_this.into();
         }
         if let Some(value) = meta.const_expand_enter(&this) {
@@ -1073,8 +1071,12 @@ impl_derefs!(impl for DExp => (self: self.lines): Expand);
 #[derive(Debug, PartialEq, Clone)]
 pub struct ValueBind(pub Box<Value>, pub Var);
 impl ValueBind {
-    pub fn take_unfollow_handle(self, meta: &mut CompileMeta) -> Var {
+    pub fn take_unfollow_handle(mut self, meta: &mut CompileMeta) -> Var {
         let handle = self.0.take_handle(meta);
+        if let Some(bind_name) = self.1.strip_suffix(LSP_DEBUG) {
+            meta.debug_binds_status(handle.clone());
+            self.1 = bind_name.into();
+        }
         meta.get_value_binded(handle, self.1)
     }
 }
@@ -4171,9 +4173,17 @@ pub trait CompileMetaExtends {
     fn display_binds(&self, value: BindsDisplayer<'_>) -> Cow<'_, str>;
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Emulate {
+    Const,
+    Binder,
+    ConstBind(Var),
+    NakedBind(Var),
+}
+
 #[derive(Debug)]
 pub struct EmulateInfo {
-    pub exist_vars: Vec<Var>,
+    pub exist_vars: Vec<(Emulate, Var)>,
 }
 
 pub struct CompileMeta {
@@ -4438,22 +4448,44 @@ impl CompileMeta {
         }
     }
 
-    fn debug_status(&mut self) {
+    fn debug_expand_env_status(&mut self) {
         if !self.is_emulated {
             return;
         }
         let mut printed = HashSet::new();
         let mut vars = vec![];
-        for env in self.expand_env.iter().rev() {
-            for var in env.consts.keys() {
-                if printed.insert(var) {
-                    vars.push(var.clone());
-                }
-            }
-        }
+        self.expand_env.iter().rev()
+            .flat_map(|env| env.consts.keys())
+            .map(|var| (Emulate::Const, var))
+            .chain(self.value_bind_pairs.keys().map(|var| (Emulate::Binder, var)))
+            .for_each(|(kind, var)| if printed.insert(var) {
+                vars.push((kind, var.clone()));
+            });
         self.emulate_infos.push(EmulateInfo { exist_vars: vars });
     }
 
+    fn debug_binds_status(&mut self, handle: Var) {
+        if !self.is_emulated {
+            return;
+        }
+        let bind_vars = self.with_get_binds(handle.clone(), |bind| {
+            let mut is_const = HashSet::new();
+            let mut bind_vars = bind.bind_names.take().unwrap()
+                .inspect(|(var, _)| _ = is_const.insert(*var))
+                .map(|(var, _)| (Emulate::ConstBind(handle.clone()), var.clone()))
+                .collect::<Vec<_>>();
+
+            if let Some(pairs) = self.value_bind_pairs.get(&handle) {
+                let naked_binds = pairs.keys()
+                    .filter(|var| !is_const.contains(var))
+                    .map(|var| (Emulate::NakedBind(handle.clone()), var.clone()));
+                bind_vars.extend(naked_binds);
+            }
+            bind_vars
+        });
+        self.emulate_infos.push(EmulateInfo { exist_vars: bind_vars });
+    }
+
     /// 进入一个拥有子命名空间的子块
     /// 返回该子块结束后的命名空间
     pub fn with_block(&mut self,