完成 bangls 的启发式片段补全 (参数系统)

Author: A4-Tacks

Cargo.lock

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

tools/bangls/Cargo.toml

@@ -26,7 +26,7 @@ bangls 是一个 bang 语言的语言服务器, 使用语言服务器协议 (LSP
 - [x] 基本补全
 - [x] 实时分析
 - [x] 报错显示
-- [ ] 启发式片段补全
+- [x] 启发式片段补全
 - [ ] 定义跳转
 - [ ] 引用跳转
 - [x] 文档查看

tools/bangls/README.md

@@ -8,7 +8,7 @@ use display_source::DisplaySourceMeta;
 use line_column::line_column;
 use linked_hash_map::LinkedHashMap;
 use lsp_server::{IoThreads, Message};
-use lsp_types::{CompletionItem, CompletionItemKind, CompletionOptions, Diagnostic, DiagnosticSeverity, InitializeParams, InitializeResult, MessageType, Position, ServerCapabilities, ShowMessageParams, TextDocumentSyncCapability, TextDocumentSyncKind, Uri, notification::{self, Notification}, request::{self, Request}};
+use lsp_types::{CompletionItem, CompletionItemKind, CompletionOptions, Diagnostic, DiagnosticSeverity, InitializeParams, InitializeResult, InsertTextFormat, MessageType, Position, ServerCapabilities, ShowMessageParams, TextDocumentSyncCapability, TextDocumentSyncKind, Uri, notification::{self, Notification}, request::{self, Request}};
 use syntax::{Compile, CompileMeta, CompileMetaExtends, Emulate, EmulateInfo, Expand, LSP_DEBUG, LSP_HOVER};
 
 fn main() {
@@ -318,21 +318,26 @@ impl RequestHandler for request::DocumentDiagnosticRequest {
 }
 
 fn generate_completes(infos: &[EmulateInfo]) -> Vec<CompletionItem> {
+    let on_line_first = infos.iter().any(|it| it.in_other_line_first);
     let infos = infos.iter()
         .filter_map(|it| it.exist_vars.as_ref());
     let full_count = infos.clone().count() as u32;
-    let mut var_counter: LinkedHashMap<&syntax::Var, (u32, Vec<_>)> = LinkedHashMap::new();
+    let mut var_counter: LinkedHashMap<&syntax::Var, (u32, Vec<_>, bool)> = LinkedHashMap::new();
     for info in infos {
-        for (kind, var) in info {
+        for (kind, var, use_args) in info {
             if var.starts_with("__") {
                 continue;
             }
-            let (slot, kinds) = var_counter.entry(var).or_default();
+            let (slot, kinds, use_args_slot)
+                = var_counter.entry(var).or_default();
             *slot += 1;
+            *use_args_slot |= *use_args;
             kinds.push(kind);
         }
     }
-    let mut items: Vec<CompletionItem> = var_counter.iter().map(|(&var, &(count, ref kinds))| {
+    let mut items: Vec<CompletionItem> = var_counter.iter().map(
+        |(&var, &(count, ref kinds, use_args))|
+    {
         let is_full_deps = count == full_count;
 
         let mut first_kind = None;
@@ -358,11 +363,20 @@ fn generate_completes(infos: &[EmulateInfo]) -> Vec<CompletionItem> {
             Emulate::NakedBind(_) => CompletionItemKind::FIELD,
         });
 
+        let insert_snippet = match (use_args, on_line_first) {
+            (true, true) => format!("{var}!$0;"),
+            (true, false) => format!("{var}[$0]"),
+            _ => var.to_string(),
+        };
+        let insert_text_format = (*insert_snippet != **var)
+            .then_some(InsertTextFormat::SNIPPET);
+
         CompletionItem {
             label,
             detail: Some(detail),
             kind: first_kind,
-            insert_text: Some(var.to_string()),
+            insert_text: Some(insert_snippet),
+            insert_text_format,
             ..Default::default()
         }
     }).collect();

tools/bangls/src/main.rs

@@ -312,6 +312,47 @@ impl Value {
     pub fn is_value_bind(&self) -> bool {
         matches!(self, Self::ValueBind(..))
     }
+
+    fn like_used_args_system(&self, meta: &CompileMeta) -> bool {
+        let value = match self {
+            Value::Var(var) => meta.get_const_value(var).map(|d| &d.value),
+            _ => Some(self),
+        };
+        let Some(slot) = value else { return false };
+        let mut slot = slot.clone();
+        for _ in 0..8 {
+            match slot {
+                Value::Var(_) | Value::ReprVar(_) | Value::ResultHandle |
+                Value::Cmper(_) | Value::Binder => return false,
+                Value::BuiltinFunc(_) => return true,
+                Value::ClosuredValue(ClosuredValue::Uninit { value, .. }) => slot = *value,
+                Value::ClosuredValue(ClosuredValue::Inited { bind_handle, .. }) => {
+                    match meta.view_bind(&ClosuredValue::make_valkey(bind_handle.clone()).into()) {
+                        Ok(value) => slot = value,
+                        Err(_) => return false,
+                    }
+                },
+                Value::ClosuredValue(_) => return false,
+                value @ (Value::ValueBind(_) | Value::ValueBindRef(_)) => {
+                    match meta.view_bind(&value) {
+                        Ok(value) => slot = value,
+                        Err(_) => return false,
+                    }
+                },
+                Value::DExp(dexp) => return dexp.lines.iter().find_map(|line| {
+                    match line {
+                        LogicLine::ArgsRepeat(_) => Some(true),
+                        LogicLine::Match(m) => Some(m.args.is_expanded()),
+                        LogicLine::ConstMatch(m) => Some(m.args.is_expanded()),
+                        LogicLine::Other(args) => Some(args.is_expanded()),
+                        LogicLine::SetArgs(args) => Some(args.is_expanded()),
+                        _ => None,
+                    }
+                }).unwrap_or(false),
+            }
+        }
+        false
+    }
 }
 impl TakeHandle for Value {
     fn take_handle(self, meta: &mut CompileMeta) -> Var {
@@ -3831,6 +3872,16 @@ impl Compile for LogicLine {
                 meta.push(lab.to_string().into())
             },
             Self::Other(args) => {
+                if meta.is_emulated && let Some(normal) = args.as_normal()
+                    && let Some(first) = normal.first()
+                    && let Some(var) = first.as_var()
+                    && var.ends_with(LSP_DEBUG)
+                {
+                    meta.emulate(EmulateInfo {
+                        in_other_line_first: true,
+                        ..Default::default()
+                    });
+                }
                 let handles: Vec<Var> = args.into_taked_args_handle(meta);
                 let args = handles.into_iter()
                     .map_to_string()
@@ -4193,11 +4244,13 @@ pub enum Emulate {
 
 #[derive(Debug, Default)]
 pub struct EmulateInfo {
-    pub exist_vars: Option<Vec<(Emulate, Var)>>,
+    /// ...needs arg system
+    pub exist_vars: Option<Vec<(Emulate, Var, bool)>>,
     pub location: Option<(u32, u32)>,
     pub diagnostic: Option<String>,
     pub is_error: bool,
     pub hover_doc: Option<String>,
+    pub in_other_line_first: bool,
 }
 
 struct HoverGuard<'a> { meta: &'a mut CompileMeta, handle: Option<Var> }
@@ -4534,7 +4587,8 @@ impl CompileMeta {
             .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()));
+                let value = Value::from(var.clone());
+                vars.push((kind, var.clone(), value.like_used_args_system(self)));
             });
         self.emulate(EmulateInfo { exist_vars: Some(vars), ..Default::default() });
     }
@@ -4562,13 +4616,16 @@ impl CompileMeta {
             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()))
+                .map(|(var, _)| {
+                    let value = Value::from(var);
+                    (Emulate::ConstBind(handle.clone()), var.clone(), value.like_used_args_system(self))
+                })
                 .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()));
+                    .map(|var| (Emulate::NakedBind(handle.clone()), var.clone(), false));
                 bind_vars.extend(naked_binds);
             }
             bind_vars